FileBackendStore.php

Go to the documentation of this file.

<?php
abstract class FileBackendStore extends FileBackend {
    protected $memCache;
    protected $srvCache;
    protected $cheapCache;
    protected $expensiveCache;
 
    protected $shardViaHashLevels = [];
 
    protected $mimeCallback;
 
    protected $maxFileSize = 4294967296; // integer bytes (4GiB)
 
    const CACHE_TTL = 10; // integer; TTL in seconds for process cache entries
    const CACHE_CHEAP_SIZE = 500; // integer; max entries in "cheap cache"
    const CACHE_EXPENSIVE_SIZE = 5; // integer; max entries in "expensive cache"
 
    public function __construct( array $config ) {
        parent::__construct( $config );
        $this->mimeCallback = isset( $config['mimeCallback'] )
            ? $config['mimeCallback']
            : null;
        $this->srvCache = new EmptyBagOStuff(); // disabled by default
        $this->memCache = WANObjectCache::newEmpty(); // disabled by default
        $this->cheapCache = new ProcessCacheLRU( self::CACHE_CHEAP_SIZE );
        $this->expensiveCache = new ProcessCacheLRU( self::CACHE_EXPENSIVE_SIZE );
    }
 
    final public function maxFileSizeInternal() {
        return $this->maxFileSize;
    }
 
    abstract public function isPathUsableInternal( $storagePath );
 
    final public function createInternal( array $params ) {
        $ps = $this->scopedProfileSection( __METHOD__ . "-{$this->name}" );
        if ( strlen( $params['content'] ) > $this->maxFileSizeInternal() ) {
            $status = $this->newStatus( 'backend-fail-maxsize',
                $params['dst'], $this->maxFileSizeInternal() );
        } else {
            $status = $this->doCreateInternal( $params );
            $this->clearCache( [ $params['dst'] ] );
            if ( !isset( $params['dstExists'] ) || $params['dstExists'] ) {
                $this->deleteFileCache( $params['dst'] ); // persistent cache
            }
        }
 
        return $status;
    }
 
    abstract protected function doCreateInternal( array $params );
 
    final public function storeInternal( array $params ) {
        $ps = $this->scopedProfileSection( __METHOD__ . "-{$this->name}" );
        if ( filesize( $params['src'] ) > $this->maxFileSizeInternal() ) {
            $status = $this->newStatus( 'backend-fail-maxsize',
                $params['dst'], $this->maxFileSizeInternal() );
        } else {
            $status = $this->doStoreInternal( $params );
            $this->clearCache( [ $params['dst'] ] );
            if ( !isset( $params['dstExists'] ) || $params['dstExists'] ) {
                $this->deleteFileCache( $params['dst'] ); // persistent cache
            }
        }
 
        return $status;
    }
 
    abstract protected function doStoreInternal( array $params );
 
    final public function copyInternal( array $params ) {
        $ps = $this->scopedProfileSection( __METHOD__ . "-{$this->name}" );
        $status = $this->doCopyInternal( $params );
        $this->clearCache( [ $params['dst'] ] );
        if ( !isset( $params['dstExists'] ) || $params['dstExists'] ) {
            $this->deleteFileCache( $params['dst'] ); // persistent cache
        }
 
        return $status;
    }
 
    abstract protected function doCopyInternal( array $params );
 
    final public function deleteInternal( array $params ) {
        $ps = $this->scopedProfileSection( __METHOD__ . "-{$this->name}" );
        $status = $this->doDeleteInternal( $params );
        $this->clearCache( [ $params['src'] ] );
        $this->deleteFileCache( $params['src'] ); // persistent cache
        return $status;
    }
 
    abstract protected function doDeleteInternal( array $params );
 
    final public function moveInternal( array $params ) {
        $ps = $this->scopedProfileSection( __METHOD__ . "-{$this->name}" );
        $status = $this->doMoveInternal( $params );
        $this->clearCache( [ $params['src'], $params['dst'] ] );
        $this->deleteFileCache( $params['src'] ); // persistent cache
        if ( !isset( $params['dstExists'] ) || $params['dstExists'] ) {
            $this->deleteFileCache( $params['dst'] ); // persistent cache
        }
 
        return $status;
    }
 
    protected function doMoveInternal( array $params ) {
        unset( $params['async'] ); // two steps, won't work here :)
        $nsrc = FileBackend::normalizeStoragePath( $params['src'] );
        $ndst = FileBackend::normalizeStoragePath( $params['dst'] );
        // Copy source to dest
        $status = $this->copyInternal( $params );
        if ( $nsrc !== $ndst && $status->isOK() ) {
            // Delete source (only fails due to races or network problems)
            $status->merge( $this->deleteInternal( [ 'src' => $params['src'] ] ) );
            $status->setResult( true, $status->value ); // ignore delete() errors
        }
 
        return $status;
    }
 
    final public function describeInternal( array $params ) {
        $ps = $this->scopedProfileSection( __METHOD__ . "-{$this->name}" );
        if ( count( $params['headers'] ) ) {
            $status = $this->doDescribeInternal( $params );
            $this->clearCache( [ $params['src'] ] );
            $this->deleteFileCache( $params['src'] ); // persistent cache
        } else {
            $status = $this->newStatus(); // nothing to do
        }
 
        return $status;
    }
 
    protected function doDescribeInternal( array $params ) {
        return $this->newStatus();
    }
 
    final public function nullInternal( array $params ) {
        return $this->newStatus();
    }
 
    final public function concatenate( array $params ) {
        $ps = $this->scopedProfileSection( __METHOD__ . "-{$this->name}" );
        $status = $this->newStatus();
 
        // Try to lock the source files for the scope of this function
        $scopeLockS = $this->getScopedFileLocks( $params['srcs'], LockManager::LOCK_UW, $status );
        if ( $status->isOK() ) {
            // Actually do the file concatenation...
            $start_time = microtime( true );
            $status->merge( $this->doConcatenate( $params ) );
            $sec = microtime( true ) - $start_time;
            if ( !$status->isOK() ) {
                $this->logger->error( get_class( $this ) . "-{$this->name}" .
                    " failed to concatenate " . count( $params['srcs'] ) . " file(s) [$sec sec]" );
            }
        }
 
        return $status;
    }
 
    protected function doConcatenate( array $params ) {
        $status = $this->newStatus();
        $tmpPath = $params['dst']; // convenience
        unset( $params['latest'] ); // sanity
 
        // Check that the specified temp file is valid...
        MediaWiki\suppressWarnings();
        $ok = ( is_file( $tmpPath ) && filesize( $tmpPath ) == 0 );
        MediaWiki\restoreWarnings();
        if ( !$ok ) { // not present or not empty
            $status->fatal( 'backend-fail-opentemp', $tmpPath );
 
            return $status;
        }
 
        // Get local FS versions of the chunks needed for the concatenation...
        $fsFiles = $this->getLocalReferenceMulti( $params );
        foreach ( $fsFiles as $path => &$fsFile ) {
            if ( !$fsFile ) { // chunk failed to download?
                $fsFile = $this->getLocalReference( [ 'src' => $path ] );
                if ( !$fsFile ) { // retry failed?
                    $status->fatal( 'backend-fail-read', $path );
 
                    return $status;
                }
            }
        }
        unset( $fsFile ); // unset reference so we can reuse $fsFile
 
        // Get a handle for the destination temp file
        $tmpHandle = fopen( $tmpPath, 'ab' );
        if ( $tmpHandle === false ) {
            $status->fatal( 'backend-fail-opentemp', $tmpPath );
 
            return $status;
        }
 
        // Build up the temp file using the source chunks (in order)...
        foreach ( $fsFiles as $virtualSource => $fsFile ) {
            // Get a handle to the local FS version
            $sourceHandle = fopen( $fsFile->getPath(), 'rb' );
            if ( $sourceHandle === false ) {
                fclose( $tmpHandle );
                $status->fatal( 'backend-fail-read', $virtualSource );
 
                return $status;
            }
            // Append chunk to file (pass chunk size to avoid magic quotes)
            if ( !stream_copy_to_stream( $sourceHandle, $tmpHandle ) ) {
                fclose( $sourceHandle );
                fclose( $tmpHandle );
                $status->fatal( 'backend-fail-writetemp', $tmpPath );
 
                return $status;
            }
            fclose( $sourceHandle );
        }
        if ( !fclose( $tmpHandle ) ) {
            $status->fatal( 'backend-fail-closetemp', $tmpPath );
 
            return $status;
        }
 
        clearstatcache(); // temp file changed
 
        return $status;
    }
 
    final protected function doPrepare( array $params ) {
        $ps = $this->scopedProfileSection( __METHOD__ . "-{$this->name}" );
        $status = $this->newStatus();
 
        list( $fullCont, $dir, $shard ) = $this->resolveStoragePath( $params['dir'] );
        if ( $dir === null ) {
            $status->fatal( 'backend-fail-invalidpath', $params['dir'] );
 
            return $status; // invalid storage path
        }
 
        if ( $shard !== null ) { // confined to a single container/shard
            $status->merge( $this->doPrepareInternal( $fullCont, $dir, $params ) );
        } else { // directory is on several shards
            $this->logger->debug( __METHOD__ . ": iterating over all container shards.\n" );
            list( , $shortCont, ) = self::splitStoragePath( $params['dir'] );
            foreach ( $this->getContainerSuffixes( $shortCont ) as $suffix ) {
                $status->merge( $this->doPrepareInternal( "{$fullCont}{$suffix}", $dir, $params ) );
            }
        }
 
        return $status;
    }
 
    protected function doPrepareInternal( $container, $dir, array $params ) {
        return $this->newStatus();
    }
 
    final protected function doSecure( array $params ) {
        $ps = $this->scopedProfileSection( __METHOD__ . "-{$this->name}" );
        $status = $this->newStatus();
 
        list( $fullCont, $dir, $shard ) = $this->resolveStoragePath( $params['dir'] );
        if ( $dir === null ) {
            $status->fatal( 'backend-fail-invalidpath', $params['dir'] );
 
            return $status; // invalid storage path
        }
 
        if ( $shard !== null ) { // confined to a single container/shard
            $status->merge( $this->doSecureInternal( $fullCont, $dir, $params ) );
        } else { // directory is on several shards
            $this->logger->debug( __METHOD__ . ": iterating over all container shards.\n" );
            list( , $shortCont, ) = self::splitStoragePath( $params['dir'] );
            foreach ( $this->getContainerSuffixes( $shortCont ) as $suffix ) {
                $status->merge( $this->doSecureInternal( "{$fullCont}{$suffix}", $dir, $params ) );
            }
        }
 
        return $status;
    }
 
    protected function doSecureInternal( $container, $dir, array $params ) {
        return $this->newStatus();
    }
 
    final protected function doPublish( array $params ) {
        $ps = $this->scopedProfileSection( __METHOD__ . "-{$this->name}" );
        $status = $this->newStatus();
 
        list( $fullCont, $dir, $shard ) = $this->resolveStoragePath( $params['dir'] );
        if ( $dir === null ) {
            $status->fatal( 'backend-fail-invalidpath', $params['dir'] );
 
            return $status; // invalid storage path
        }
 
        if ( $shard !== null ) { // confined to a single container/shard
            $status->merge( $this->doPublishInternal( $fullCont, $dir, $params ) );
        } else { // directory is on several shards
            $this->logger->debug( __METHOD__ . ": iterating over all container shards.\n" );
            list( , $shortCont, ) = self::splitStoragePath( $params['dir'] );
            foreach ( $this->getContainerSuffixes( $shortCont ) as $suffix ) {
                $status->merge( $this->doPublishInternal( "{$fullCont}{$suffix}", $dir, $params ) );
            }
        }
 
        return $status;
    }
 
    protected function doPublishInternal( $container, $dir, array $params ) {
        return $this->newStatus();
    }
 
    final protected function doClean( array $params ) {
        $ps = $this->scopedProfileSection( __METHOD__ . "-{$this->name}" );
        $status = $this->newStatus();
 
        // Recursive: first delete all empty subdirs recursively
        if ( !empty( $params['recursive'] ) && !$this->directoriesAreVirtual() ) {
            $subDirsRel = $this->getTopDirectoryList( [ 'dir' => $params['dir'] ] );
            if ( $subDirsRel !== null ) { // no errors
                foreach ( $subDirsRel as $subDirRel ) {
                    $subDir = $params['dir'] . "/{$subDirRel}"; // full path
                    $status->merge( $this->doClean( [ 'dir' => $subDir ] + $params ) );
                }
                unset( $subDirsRel ); // free directory for rmdir() on Windows (for FS backends)
            }
        }
 
        list( $fullCont, $dir, $shard ) = $this->resolveStoragePath( $params['dir'] );
        if ( $dir === null ) {
            $status->fatal( 'backend-fail-invalidpath', $params['dir'] );
 
            return $status; // invalid storage path
        }
 
        // Attempt to lock this directory...
        $filesLockEx = [ $params['dir'] ];
        $scopedLockE = $this->getScopedFileLocks( $filesLockEx, LockManager::LOCK_EX, $status );
        if ( !$status->isOK() ) {
            return $status; // abort
        }
 
        if ( $shard !== null ) { // confined to a single container/shard
            $status->merge( $this->doCleanInternal( $fullCont, $dir, $params ) );
            $this->deleteContainerCache( $fullCont ); // purge cache
        } else { // directory is on several shards
            $this->logger->debug( __METHOD__ . ": iterating over all container shards.\n" );
            list( , $shortCont, ) = self::splitStoragePath( $params['dir'] );
            foreach ( $this->getContainerSuffixes( $shortCont ) as $suffix ) {
                $status->merge( $this->doCleanInternal( "{$fullCont}{$suffix}", $dir, $params ) );
                $this->deleteContainerCache( "{$fullCont}{$suffix}" ); // purge cache
            }
        }
 
        return $status;
    }
 
    protected function doCleanInternal( $container, $dir, array $params ) {
        return $this->newStatus();
    }
 
    final public function fileExists( array $params ) {
        $ps = $this->scopedProfileSection( __METHOD__ . "-{$this->name}" );
        $stat = $this->getFileStat( $params );
 
        return ( $stat === null ) ? null : (bool)$stat; // null => failure
    }
 
    final public function getFileTimestamp( array $params ) {
        $ps = $this->scopedProfileSection( __METHOD__ . "-{$this->name}" );
        $stat = $this->getFileStat( $params );
 
        return $stat ? $stat['mtime'] : false;
    }
 
    final public function getFileSize( array $params ) {
        $ps = $this->scopedProfileSection( __METHOD__ . "-{$this->name}" );
        $stat = $this->getFileStat( $params );
 
        return $stat ? $stat['size'] : false;
    }
 
    final public function getFileStat( array $params ) {
        $path = self::normalizeStoragePath( $params['src'] );
        if ( $path === null ) {
            return false; // invalid storage path
        }
        $ps = $this->scopedProfileSection( __METHOD__ . "-{$this->name}" );
        $latest = !empty( $params['latest'] ); // use latest data?
        if ( !$latest && !$this->cheapCache->has( $path, 'stat', self::CACHE_TTL ) ) {
            $this->primeFileCache( [ $path ] ); // check persistent cache
        }
        if ( $this->cheapCache->has( $path, 'stat', self::CACHE_TTL ) ) {
            $stat = $this->cheapCache->get( $path, 'stat' );
            // If we want the latest data, check that this cached
            // value was in fact fetched with the latest available data.
            if ( is_array( $stat ) ) {
                if ( !$latest || $stat['latest'] ) {
                    return $stat;
                }
            } elseif ( in_array( $stat, [ 'NOT_EXIST', 'NOT_EXIST_LATEST' ] ) ) {
                if ( !$latest || $stat === 'NOT_EXIST_LATEST' ) {
                    return false;
                }
            }
        }
        $stat = $this->doGetFileStat( $params );
        if ( is_array( $stat ) ) { // file exists
            // Strongly consistent backends can automatically set "latest"
            $stat['latest'] = isset( $stat['latest'] ) ? $stat['latest'] : $latest;
            $this->cheapCache->set( $path, 'stat', $stat );
            $this->setFileCache( $path, $stat ); // update persistent cache
            if ( isset( $stat['sha1'] ) ) { // some backends store SHA-1 as metadata
                $this->cheapCache->set( $path, 'sha1',
                    [ 'hash' => $stat['sha1'], 'latest' => $latest ] );
            }
            if ( isset( $stat['xattr'] ) ) { // some backends store headers/metadata
                $stat['xattr'] = self::normalizeXAttributes( $stat['xattr'] );
                $this->cheapCache->set( $path, 'xattr',
                    [ 'map' => $stat['xattr'], 'latest' => $latest ] );
            }
        } elseif ( $stat === false ) { // file does not exist
            $this->cheapCache->set( $path, 'stat', $latest ? 'NOT_EXIST_LATEST' : 'NOT_EXIST' );
            $this->cheapCache->set( $path, 'xattr', [ 'map' => false, 'latest' => $latest ] );
            $this->cheapCache->set( $path, 'sha1', [ 'hash' => false, 'latest' => $latest ] );
            $this->logger->debug( __METHOD__ . ": File $path does not exist.\n" );
        } else { // an error occurred
            $this->logger->warning( __METHOD__ . ": Could not stat file $path.\n" );
        }
 
        return $stat;
    }
 
    abstract protected function doGetFileStat( array $params );
 
    public function getFileContentsMulti( array $params ) {
        $ps = $this->scopedProfileSection( __METHOD__ . "-{$this->name}" );
 
        $params = $this->setConcurrencyFlags( $params );
        $contents = $this->doGetFileContentsMulti( $params );
 
        return $contents;
    }
 
    protected function doGetFileContentsMulti( array $params ) {
        $contents = [];
        foreach ( $this->doGetLocalReferenceMulti( $params ) as $path => $fsFile ) {
            MediaWiki\suppressWarnings();
            $contents[$path] = $fsFile ? file_get_contents( $fsFile->getPath() ) : false;
            MediaWiki\restoreWarnings();
        }
 
        return $contents;
    }
 
    final public function getFileXAttributes( array $params ) {
        $path = self::normalizeStoragePath( $params['src'] );
        if ( $path === null ) {
            return false; // invalid storage path
        }
        $ps = $this->scopedProfileSection( __METHOD__ . "-{$this->name}" );
        $latest = !empty( $params['latest'] ); // use latest data?
        if ( $this->cheapCache->has( $path, 'xattr', self::CACHE_TTL ) ) {
            $stat = $this->cheapCache->get( $path, 'xattr' );
            // If we want the latest data, check that this cached
            // value was in fact fetched with the latest available data.
            if ( !$latest || $stat['latest'] ) {
                return $stat['map'];
            }
        }
        $fields = $this->doGetFileXAttributes( $params );
        $fields = is_array( $fields ) ? self::normalizeXAttributes( $fields ) : false;
        $this->cheapCache->set( $path, 'xattr', [ 'map' => $fields, 'latest' => $latest ] );
 
        return $fields;
    }
 
    protected function doGetFileXAttributes( array $params ) {
        return [ 'headers' => [], 'metadata' => [] ]; // not supported
    }
 
    final public function getFileSha1Base36( array $params ) {
        $path = self::normalizeStoragePath( $params['src'] );
        if ( $path === null ) {
            return false; // invalid storage path
        }
        $ps = $this->scopedProfileSection( __METHOD__ . "-{$this->name}" );
        $latest = !empty( $params['latest'] ); // use latest data?
        if ( $this->cheapCache->has( $path, 'sha1', self::CACHE_TTL ) ) {
            $stat = $this->cheapCache->get( $path, 'sha1' );
            // If we want the latest data, check that this cached
            // value was in fact fetched with the latest available data.
            if ( !$latest || $stat['latest'] ) {
                return $stat['hash'];
            }
        }
        $hash = $this->doGetFileSha1Base36( $params );
        $this->cheapCache->set( $path, 'sha1', [ 'hash' => $hash, 'latest' => $latest ] );
 
        return $hash;
    }
 
    protected function doGetFileSha1Base36( array $params ) {
        $fsFile = $this->getLocalReference( $params );
        if ( !$fsFile ) {
            return false;
        } else {
            return $fsFile->getSha1Base36();
        }
    }
 
    final public function getFileProps( array $params ) {
        $ps = $this->scopedProfileSection( __METHOD__ . "-{$this->name}" );
        $fsFile = $this->getLocalReference( $params );
        $props = $fsFile ? $fsFile->getProps() : FSFile::placeholderProps();
 
        return $props;
    }
 
    final public function getLocalReferenceMulti( array $params ) {
        $ps = $this->scopedProfileSection( __METHOD__ . "-{$this->name}" );
 
        $params = $this->setConcurrencyFlags( $params );
 
        $fsFiles = []; // (path => FSFile)
        $latest = !empty( $params['latest'] ); // use latest data?
        // Reuse any files already in process cache...
        foreach ( $params['srcs'] as $src ) {
            $path = self::normalizeStoragePath( $src );
            if ( $path === null ) {
                $fsFiles[$src] = null; // invalid storage path
            } elseif ( $this->expensiveCache->has( $path, 'localRef' ) ) {
                $val = $this->expensiveCache->get( $path, 'localRef' );
                // If we want the latest data, check that this cached
                // value was in fact fetched with the latest available data.
                if ( !$latest || $val['latest'] ) {
                    $fsFiles[$src] = $val['object'];
                }
            }
        }
        // Fetch local references of any remaning files...
        $params['srcs'] = array_diff( $params['srcs'], array_keys( $fsFiles ) );
        foreach ( $this->doGetLocalReferenceMulti( $params ) as $path => $fsFile ) {
            $fsFiles[$path] = $fsFile;
            if ( $fsFile ) { // update the process cache...
                $this->expensiveCache->set( $path, 'localRef',
                    [ 'object' => $fsFile, 'latest' => $latest ] );
            }
        }
 
        return $fsFiles;
    }
 
    protected function doGetLocalReferenceMulti( array $params ) {
        return $this->doGetLocalCopyMulti( $params );
    }
 
    final public function getLocalCopyMulti( array $params ) {
        $ps = $this->scopedProfileSection( __METHOD__ . "-{$this->name}" );
 
        $params = $this->setConcurrencyFlags( $params );
        $tmpFiles = $this->doGetLocalCopyMulti( $params );
 
        return $tmpFiles;
    }
 
    abstract protected function doGetLocalCopyMulti( array $params );
 
    public function getFileHttpUrl( array $params ) {
        return null; // not supported
    }
 
    final public function streamFile( array $params ) {
        $ps = $this->scopedProfileSection( __METHOD__ . "-{$this->name}" );
        $status = $this->newStatus();
 
        // Always set some fields for subclass convenience
        $params['options'] = isset( $params['options'] ) ? $params['options'] : [];
        $params['headers'] = isset( $params['headers'] ) ? $params['headers'] : [];
 
        // Don't stream it out as text/html if there was a PHP error
        if ( ( empty( $params['headless'] ) || $params['headers'] ) && headers_sent() ) {
            print "Headers already sent, terminating.\n";
            $status->fatal( 'backend-fail-stream', $params['src'] );
            return $status;
        }
 
        $status->merge( $this->doStreamFile( $params ) );
 
        return $status;
    }
 
    protected function doStreamFile( array $params ) {
        $status = $this->newStatus();
 
        $flags = 0;
        $flags |= !empty( $params['headless'] ) ? HTTPFileStreamer::STREAM_HEADLESS : 0;
        $flags |= !empty( $params['allowOB'] ) ? HTTPFileStreamer::STREAM_ALLOW_OB : 0;
 
        $fsFile = $this->getLocalReference( $params );
        if ( $fsFile ) {
            $streamer = new HTTPFileStreamer(
                $fsFile->getPath(),
                [
                    'obResetFunc' => $this->obResetFunc,
                    'streamMimeFunc' => $this->streamMimeFunc
                ]
            );
            $res = $streamer->stream( $params['headers'], true, $params['options'], $flags );
        } else {
            $res = false;
            HTTPFileStreamer::send404Message( $params['src'], $flags );
        }
 
        if ( !$res ) {
            $status->fatal( 'backend-fail-stream', $params['src'] );
        }
 
        return $status;
    }
 
    final public function directoryExists( array $params ) {
        list( $fullCont, $dir, $shard ) = $this->resolveStoragePath( $params['dir'] );
        if ( $dir === null ) {
            return false; // invalid storage path
        }
        if ( $shard !== null ) { // confined to a single container/shard
            return $this->doDirectoryExists( $fullCont, $dir, $params );
        } else { // directory is on several shards
            $this->logger->debug( __METHOD__ . ": iterating over all container shards.\n" );
            list( , $shortCont, ) = self::splitStoragePath( $params['dir'] );
            $res = false; // response
            foreach ( $this->getContainerSuffixes( $shortCont ) as $suffix ) {
                $exists = $this->doDirectoryExists( "{$fullCont}{$suffix}", $dir, $params );
                if ( $exists ) {
                    $res = true;
                    break; // found one!
                } elseif ( $exists === null ) { // error?
                    $res = null; // if we don't find anything, it is indeterminate
                }
            }
 
            return $res;
        }
    }
 
    abstract protected function doDirectoryExists( $container, $dir, array $params );
 
    final public function getDirectoryList( array $params ) {
        list( $fullCont, $dir, $shard ) = $this->resolveStoragePath( $params['dir'] );
        if ( $dir === null ) { // invalid storage path
            return null;
        }
        if ( $shard !== null ) {
            // File listing is confined to a single container/shard
            return $this->getDirectoryListInternal( $fullCont, $dir, $params );
        } else {
            $this->logger->debug( __METHOD__ . ": iterating over all container shards.\n" );
            // File listing spans multiple containers/shards
            list( , $shortCont, ) = self::splitStoragePath( $params['dir'] );
 
            return new FileBackendStoreShardDirIterator( $this,
                $fullCont, $dir, $this->getContainerSuffixes( $shortCont ), $params );
        }
    }
 
    abstract public function getDirectoryListInternal( $container, $dir, array $params );
 
    final public function getFileList( array $params ) {
        list( $fullCont, $dir, $shard ) = $this->resolveStoragePath( $params['dir'] );
        if ( $dir === null ) { // invalid storage path
            return null;
        }
        if ( $shard !== null ) {
            // File listing is confined to a single container/shard
            return $this->getFileListInternal( $fullCont, $dir, $params );
        } else {
            $this->logger->debug( __METHOD__ . ": iterating over all container shards.\n" );
            // File listing spans multiple containers/shards
            list( , $shortCont, ) = self::splitStoragePath( $params['dir'] );
 
            return new FileBackendStoreShardFileIterator( $this,
                $fullCont, $dir, $this->getContainerSuffixes( $shortCont ), $params );
        }
    }
 
    abstract public function getFileListInternal( $container, $dir, array $params );
 
    final public function getOperationsInternal( array $ops ) {
        $supportedOps = [
            'store' => 'StoreFileOp',
            'copy' => 'CopyFileOp',
            'move' => 'MoveFileOp',
            'delete' => 'DeleteFileOp',
            'create' => 'CreateFileOp',
            'describe' => 'DescribeFileOp',
            'null' => 'NullFileOp'
        ];
 
        $performOps = []; // array of FileOp objects
        // Build up ordered array of FileOps...
        foreach ( $ops as $operation ) {
            $opName = $operation['op'];
            if ( isset( $supportedOps[$opName] ) ) {
                $class = $supportedOps[$opName];
                // Get params for this operation
                $params = $operation;
                // Append the FileOp class
                $performOps[] = new $class( $this, $params, $this->logger );
            } else {
                throw new FileBackendError( "Operation '$opName' is not supported." );
            }
        }
 
        return $performOps;
    }
 
    final public function getPathsToLockForOpsInternal( array $performOps ) {
        // Build up a list of files to lock...
        $paths = [ 'sh' => [], 'ex' => [] ];
        foreach ( $performOps as $fileOp ) {
            $paths['sh'] = array_merge( $paths['sh'], $fileOp->storagePathsRead() );
            $paths['ex'] = array_merge( $paths['ex'], $fileOp->storagePathsChanged() );
        }
        // Optimization: if doing an EX lock anyway, don't also set an SH one
        $paths['sh'] = array_diff( $paths['sh'], $paths['ex'] );
        // Get a shared lock on the parent directory of each path changed
        $paths['sh'] = array_merge( $paths['sh'], array_map( 'dirname', $paths['ex'] ) );
 
        return [
            LockManager::LOCK_UW => $paths['sh'],
            LockManager::LOCK_EX => $paths['ex']
        ];
    }
 
    public function getScopedLocksForOps( array $ops, StatusValue $status ) {
        $paths = $this->getPathsToLockForOpsInternal( $this->getOperationsInternal( $ops ) );
 
        return $this->getScopedFileLocks( $paths, 'mixed', $status );
    }
 
    final protected function doOperationsInternal( array $ops, array $opts ) {
        $ps = $this->scopedProfileSection( __METHOD__ . "-{$this->name}" );
        $status = $this->newStatus();
 
        // Fix up custom header name/value pairs...
        $ops = array_map( [ $this, 'sanitizeOpHeaders' ], $ops );
 
        // Build up a list of FileOps...
        $performOps = $this->getOperationsInternal( $ops );
 
        // Acquire any locks as needed...
        if ( empty( $opts['nonLocking'] ) ) {
            // Build up a list of files to lock...
            $paths = $this->getPathsToLockForOpsInternal( $performOps );
            // Try to lock those files for the scope of this function...
 
            $scopeLock = $this->getScopedFileLocks( $paths, 'mixed', $status );
            if ( !$status->isOK() ) {
                return $status; // abort
            }
        }
 
        // Clear any file cache entries (after locks acquired)
        if ( empty( $opts['preserveCache'] ) ) {
            $this->clearCache();
        }
 
        // Build the list of paths involved
        $paths = [];
        foreach ( $performOps as $performOp ) {
            $paths = array_merge( $paths, $performOp->storagePathsRead() );
            $paths = array_merge( $paths, $performOp->storagePathsChanged() );
        }
 
        // Enlarge the cache to fit the stat entries of these files
        $this->cheapCache->resize( max( 2 * count( $paths ), self::CACHE_CHEAP_SIZE ) );
 
        // Load from the persistent container caches
        $this->primeContainerCache( $paths );
        // Get the latest stat info for all the files (having locked them)
        $ok = $this->preloadFileStat( [ 'srcs' => $paths, 'latest' => true ] );
 
        if ( $ok ) {
            // Actually attempt the operation batch...
            $opts = $this->setConcurrencyFlags( $opts );
            $subStatus = FileOpBatch::attempt( $performOps, $opts, $this->fileJournal );
        } else {
            // If we could not even stat some files, then bail out...
            $subStatus = $this->newStatus( 'backend-fail-internal', $this->name );
            foreach ( $ops as $i => $op ) { // mark each op as failed
                $subStatus->success[$i] = false;
                ++$subStatus->failCount;
            }
            $this->logger->error( get_class( $this ) . "-{$this->name} " .
                " stat failure; aborted operations: " . FormatJson::encode( $ops ) );
        }
 
        // Merge errors into StatusValue fields
        $status->merge( $subStatus );
        $status->success = $subStatus->success; // not done in merge()
 
        // Shrink the stat cache back to normal size
        $this->cheapCache->resize( self::CACHE_CHEAP_SIZE );
 
        return $status;
    }
 
    final protected function doQuickOperationsInternal( array $ops ) {
        $ps = $this->scopedProfileSection( __METHOD__ . "-{$this->name}" );
        $status = $this->newStatus();
 
        // Fix up custom header name/value pairs...
        $ops = array_map( [ $this, 'sanitizeOpHeaders' ], $ops );
 
        // Clear any file cache entries
        $this->clearCache();
 
        $supportedOps = [ 'create', 'store', 'copy', 'move', 'delete', 'describe', 'null' ];
        // Parallel ops may be disabled in config due to dependencies (e.g. needing popen())
        $async = ( $this->parallelize === 'implicit' && count( $ops ) > 1 );
        $maxConcurrency = $this->concurrency; // throttle
        $statuses = []; // array of (index => StatusValue)
        $fileOpHandles = []; // list of (index => handle) arrays
        $curFileOpHandles = []; // current handle batch
        // Perform the sync-only ops and build up op handles for the async ops...
        foreach ( $ops as $index => $params ) {
            if ( !in_array( $params['op'], $supportedOps ) ) {
                throw new FileBackendError( "Operation '{$params['op']}' is not supported." );
            }
            $method = $params['op'] . 'Internal'; // e.g. "storeInternal"
            $subStatus = $this->$method( [ 'async' => $async ] + $params );
            if ( $subStatus->value instanceof FileBackendStoreOpHandle ) { // async
                if ( count( $curFileOpHandles ) >= $maxConcurrency ) {
                    $fileOpHandles[] = $curFileOpHandles; // push this batch
                    $curFileOpHandles = [];
                }
                $curFileOpHandles[$index] = $subStatus->value; // keep index
            } else { // error or completed
                $statuses[$index] = $subStatus; // keep index
            }
        }
        if ( count( $curFileOpHandles ) ) {
            $fileOpHandles[] = $curFileOpHandles; // last batch
        }
        // Do all the async ops that can be done concurrently...
        foreach ( $fileOpHandles as $fileHandleBatch ) {
            $statuses = $statuses + $this->executeOpHandlesInternal( $fileHandleBatch );
        }
        // Marshall and merge all the responses...
        foreach ( $statuses as $index => $subStatus ) {
            $status->merge( $subStatus );
            if ( $subStatus->isOK() ) {
                $status->success[$index] = true;
                ++$status->successCount;
            } else {
                $status->success[$index] = false;
                ++$status->failCount;
            }
        }
 
        return $status;
    }
 
    final public function executeOpHandlesInternal( array $fileOpHandles ) {
        $ps = $this->scopedProfileSection( __METHOD__ . "-{$this->name}" );
 
        foreach ( $fileOpHandles as $fileOpHandle ) {
            if ( !( $fileOpHandle instanceof FileBackendStoreOpHandle ) ) {
                throw new InvalidArgumentException( "Got a non-FileBackendStoreOpHandle object." );
            } elseif ( $fileOpHandle->backend->getName() !== $this->getName() ) {
                throw new InvalidArgumentException(
                    "Got a FileBackendStoreOpHandle for the wrong backend." );
            }
        }
        $res = $this->doExecuteOpHandlesInternal( $fileOpHandles );
        foreach ( $fileOpHandles as $fileOpHandle ) {
            $fileOpHandle->closeResources();
        }
 
        return $res;
    }
 
    protected function doExecuteOpHandlesInternal( array $fileOpHandles ) {
        if ( count( $fileOpHandles ) ) {
            throw new LogicException( "Backend does not support asynchronous operations." );
        }
 
        return [];
    }
 
    protected function sanitizeOpHeaders( array $op ) {
        static $longs = [ 'content-disposition' ];
 
        if ( isset( $op['headers'] ) ) { // op sets HTTP headers
            $newHeaders = [];
            foreach ( $op['headers'] as $name => $value ) {
                $name = strtolower( $name );
                $maxHVLen = in_array( $name, $longs ) ? INF : 255;
                if ( strlen( $name ) > 255 || strlen( $value ) > $maxHVLen ) {
                    trigger_error( "Header '$name: $value' is too long." );
                } else {
                    $newHeaders[$name] = strlen( $value ) ? $value : ''; // null/false => ""
                }
            }
            $op['headers'] = $newHeaders;
        }
 
        return $op;
    }
 
    final public function preloadCache( array $paths ) {
        $fullConts = []; // full container names
        foreach ( $paths as $path ) {
            list( $fullCont, , ) = $this->resolveStoragePath( $path );
            $fullConts[] = $fullCont;
        }
        // Load from the persistent file and container caches
        $this->primeContainerCache( $fullConts );
        $this->primeFileCache( $paths );
    }
 
    final public function clearCache( array $paths = null ) {
        if ( is_array( $paths ) ) {
            $paths = array_map( 'FileBackend::normalizeStoragePath', $paths );
            $paths = array_filter( $paths, 'strlen' ); // remove nulls
        }
        if ( $paths === null ) {
            $this->cheapCache->clear();
            $this->expensiveCache->clear();
        } else {
            foreach ( $paths as $path ) {
                $this->cheapCache->clear( $path );
                $this->expensiveCache->clear( $path );
            }
        }
        $this->doClearCache( $paths );
    }
 
    protected function doClearCache( array $paths = null ) {
    }
 
    final public function preloadFileStat( array $params ) {
        $ps = $this->scopedProfileSection( __METHOD__ . "-{$this->name}" );
        $success = true; // no network errors
 
        $params['concurrency'] = ( $this->parallelize !== 'off' ) ? $this->concurrency : 1;
        $stats = $this->doGetFileStatMulti( $params );
        if ( $stats === null ) {
            return true; // not supported
        }
 
        $latest = !empty( $params['latest'] ); // use latest data?
        foreach ( $stats as $path => $stat ) {
            $path = FileBackend::normalizeStoragePath( $path );
            if ( $path === null ) {
                continue; // this shouldn't happen
            }
            if ( is_array( $stat ) ) { // file exists
                // Strongly consistent backends can automatically set "latest"
                $stat['latest'] = isset( $stat['latest'] ) ? $stat['latest'] : $latest;
                $this->cheapCache->set( $path, 'stat', $stat );
                $this->setFileCache( $path, $stat ); // update persistent cache
                if ( isset( $stat['sha1'] ) ) { // some backends store SHA-1 as metadata
                    $this->cheapCache->set( $path, 'sha1',
                        [ 'hash' => $stat['sha1'], 'latest' => $latest ] );
                }
                if ( isset( $stat['xattr'] ) ) { // some backends store headers/metadata
                    $stat['xattr'] = self::normalizeXAttributes( $stat['xattr'] );
                    $this->cheapCache->set( $path, 'xattr',
                        [ 'map' => $stat['xattr'], 'latest' => $latest ] );
                }
            } elseif ( $stat === false ) { // file does not exist
                $this->cheapCache->set( $path, 'stat',
                    $latest ? 'NOT_EXIST_LATEST' : 'NOT_EXIST' );
                $this->cheapCache->set( $path, 'xattr',
                    [ 'map' => false, 'latest' => $latest ] );
                $this->cheapCache->set( $path, 'sha1',
                    [ 'hash' => false, 'latest' => $latest ] );
                $this->logger->debug( __METHOD__ . ": File $path does not exist.\n" );
            } else { // an error occurred
                $success = false;
                $this->logger->warning( __METHOD__ . ": Could not stat file $path.\n" );
            }
        }
 
        return $success;
    }
 
    protected function doGetFileStatMulti( array $params ) {
        return null; // not supported
    }
 
    abstract protected function directoriesAreVirtual();
 
    final protected static function isValidShortContainerName( $container ) {
        // Suffixes like '.xxx' (hex shard chars) or '.seg' (file segments)
        // might be used by subclasses. Reserve the dot character for sanity.
        // The only way dots end up in containers (e.g. resolveStoragePath)
        // is due to the wikiId container prefix or the above suffixes.
        return self::isValidContainerName( $container ) && !preg_match( '/[.]/', $container );
    }
 
    final protected static function isValidContainerName( $container ) {
        // This accounts for NTFS, Swift, and Ceph restrictions
        // and disallows directory separators or traversal characters.
        // Note that matching strings URL encode to the same string;
        // in Swift/Ceph, the length restriction is *after* URL encoding.
        return (bool)preg_match( '/^[a-z0-9][a-z0-9-_.]{0,199}$/i', $container );
    }
 
    final protected function resolveStoragePath( $storagePath ) {
        list( $backend, $shortCont, $relPath ) = self::splitStoragePath( $storagePath );
        if ( $backend === $this->name ) { // must be for this backend
            $relPath = self::normalizeContainerPath( $relPath );
            if ( $relPath !== null && self::isValidShortContainerName( $shortCont ) ) {
                // Get shard for the normalized path if this container is sharded
                $cShard = $this->getContainerShard( $shortCont, $relPath );
                // Validate and sanitize the relative path (backend-specific)
                $relPath = $this->resolveContainerPath( $shortCont, $relPath );
                if ( $relPath !== null ) {
                    // Prepend any wiki ID prefix to the container name
                    $container = $this->fullContainerName( $shortCont );
                    if ( self::isValidContainerName( $container ) ) {
                        // Validate and sanitize the container name (backend-specific)
                        $container = $this->resolveContainerName( "{$container}{$cShard}" );
                        if ( $container !== null ) {
                            return [ $container, $relPath, $cShard ];
                        }
                    }
                }
            }
        }
 
        return [ null, null, null ];
    }
 
    final protected function resolveStoragePathReal( $storagePath ) {
        list( $container, $relPath, $cShard ) = $this->resolveStoragePath( $storagePath );
        if ( $cShard !== null && substr( $relPath, -1 ) !== '/' ) {
            return [ $container, $relPath ];
        }
 
        return [ null, null ];
    }
 
    final protected function getContainerShard( $container, $relPath ) {
        list( $levels, $base, $repeat ) = $this->getContainerHashLevels( $container );
        if ( $levels == 1 || $levels == 2 ) {
            // Hash characters are either base 16 or 36
            $char = ( $base == 36 ) ? '[0-9a-z]' : '[0-9a-f]';
            // Get a regex that represents the shard portion of paths.
            // The concatenation of the captures gives us the shard.
            if ( $levels === 1 ) { // 16 or 36 shards per container
                $hashDirRegex = '(' . $char . ')';
            } else { // 256 or 1296 shards per container
                if ( $repeat ) { // verbose hash dir format (e.g. "a/ab/abc")
                    $hashDirRegex = $char . '/(' . $char . '{2})';
                } else { // short hash dir format (e.g. "a/b/c")
                    $hashDirRegex = '(' . $char . ')/(' . $char . ')';
                }
            }
            // Allow certain directories to be above the hash dirs so as
            // to work with FileRepo (e.g. "archive/a/ab" or "temp/a/ab").
            // They must be 2+ chars to avoid any hash directory ambiguity.
            $m = [];
            if ( preg_match( "!^(?:[^/]{2,}/)*$hashDirRegex(?:/|$)!", $relPath, $m ) ) {
                return '.' . implode( '', array_slice( $m, 1 ) );
            }
 
            return null; // failed to match
        }
 
        return ''; // no sharding
    }
 
    final public function isSingleShardPathInternal( $storagePath ) {
        list( , , $shard ) = $this->resolveStoragePath( $storagePath );
 
        return ( $shard !== null );
    }
 
    final protected function getContainerHashLevels( $container ) {
        if ( isset( $this->shardViaHashLevels[$container] ) ) {
            $config = $this->shardViaHashLevels[$container];
            $hashLevels = (int)$config['levels'];
            if ( $hashLevels == 1 || $hashLevels == 2 ) {
                $hashBase = (int)$config['base'];
                if ( $hashBase == 16 || $hashBase == 36 ) {
                    return [ $hashLevels, $hashBase, $config['repeat'] ];
                }
            }
        }
 
        return [ 0, 0, false ]; // no sharding
    }
 
    final protected function getContainerSuffixes( $container ) {
        $shards = [];
        list( $digits, $base ) = $this->getContainerHashLevels( $container );
        if ( $digits > 0 ) {
            $numShards = pow( $base, $digits );
            for ( $index = 0; $index < $numShards; $index++ ) {
                $shards[] = '.' . Wikimedia\base_convert( $index, 10, $base, $digits );
            }
        }
 
        return $shards;
    }
 
    final protected function fullContainerName( $container ) {
        if ( $this->domainId != '' ) {
            return "{$this->domainId}-$container";
        } else {
            return $container;
        }
    }
 
    protected function resolveContainerName( $container ) {
        return $container;
    }
 
    protected function resolveContainerPath( $container, $relStoragePath ) {
        return $relStoragePath;
    }
 
    private function containerCacheKey( $container ) {
        return "filebackend:{$this->name}:{$this->domainId}:container:{$container}";
    }
 
    final protected function setContainerCache( $container, array $val ) {
        $this->memCache->set( $this->containerCacheKey( $container ), $val, 14 * 86400 );
    }
 
    final protected function deleteContainerCache( $container ) {
        if ( !$this->memCache->delete( $this->containerCacheKey( $container ), 300 ) ) {
            trigger_error( "Unable to delete stat cache for container $container." );
        }
    }
 
    final protected function primeContainerCache( array $items ) {
        $ps = $this->scopedProfileSection( __METHOD__ . "-{$this->name}" );
 
        $paths = []; // list of storage paths
        $contNames = []; // (cache key => resolved container name)
        // Get all the paths/containers from the items...
        foreach ( $items as $item ) {
            if ( self::isStoragePath( $item ) ) {
                $paths[] = $item;
            } elseif ( is_string( $item ) ) { // full container name
                $contNames[$this->containerCacheKey( $item )] = $item;
            }
        }
        // Get all the corresponding cache keys for paths...
        foreach ( $paths as $path ) {
            list( $fullCont, , ) = $this->resolveStoragePath( $path );
            if ( $fullCont !== null ) { // valid path for this backend
                $contNames[$this->containerCacheKey( $fullCont )] = $fullCont;
            }
        }
 
        $contInfo = []; // (resolved container name => cache value)
        // Get all cache entries for these container cache keys...
        $values = $this->memCache->getMulti( array_keys( $contNames ) );
        foreach ( $values as $cacheKey => $val ) {
            $contInfo[$contNames[$cacheKey]] = $val;
        }
 
        // Populate the container process cache for the backend...
        $this->doPrimeContainerCache( array_filter( $contInfo, 'is_array' ) );
    }
 
    protected function doPrimeContainerCache( array $containerInfo ) {
    }
 
    private function fileCacheKey( $path ) {
        return "filebackend:{$this->name}:{$this->domainId}:file:" . sha1( $path );
    }
 
    final protected function setFileCache( $path, array $val ) {
        $path = FileBackend::normalizeStoragePath( $path );
        if ( $path === null ) {
            return; // invalid storage path
        }
        $mtime = ConvertibleTimestamp::convert( TS_UNIX, $val['mtime'] );
        $ttl = $this->memCache->adaptiveTTL( $mtime, 7 * 86400, 300, .1 );
        $key = $this->fileCacheKey( $path );
        // Set the cache unless it is currently salted.
        $this->memCache->set( $key, $val, $ttl );
    }
 
    final protected function deleteFileCache( $path ) {
        $path = FileBackend::normalizeStoragePath( $path );
        if ( $path === null ) {
            return; // invalid storage path
        }
        if ( !$this->memCache->delete( $this->fileCacheKey( $path ), 300 ) ) {
            trigger_error( "Unable to delete stat cache for file $path." );
        }
    }
 
    final protected function primeFileCache( array $items ) {
        $ps = $this->scopedProfileSection( __METHOD__ . "-{$this->name}" );
 
        $paths = []; // list of storage paths
        $pathNames = []; // (cache key => storage path)
        // Get all the paths/containers from the items...
        foreach ( $items as $item ) {
            if ( self::isStoragePath( $item ) ) {
                $paths[] = FileBackend::normalizeStoragePath( $item );
            }
        }
        // Get rid of any paths that failed normalization...
        $paths = array_filter( $paths, 'strlen' ); // remove nulls
        // Get all the corresponding cache keys for paths...
        foreach ( $paths as $path ) {
            list( , $rel, ) = $this->resolveStoragePath( $path );
            if ( $rel !== null ) { // valid path for this backend
                $pathNames[$this->fileCacheKey( $path )] = $path;
            }
        }
        // Get all cache entries for these file cache keys...
        $values = $this->memCache->getMulti( array_keys( $pathNames ) );
        foreach ( $values as $cacheKey => $val ) {
            $path = $pathNames[$cacheKey];
            if ( is_array( $val ) ) {
                $val['latest'] = false; // never completely trust cache
                $this->cheapCache->set( $path, 'stat', $val );
                if ( isset( $val['sha1'] ) ) { // some backends store SHA-1 as metadata
                    $this->cheapCache->set( $path, 'sha1',
                        [ 'hash' => $val['sha1'], 'latest' => false ] );
                }
                if ( isset( $val['xattr'] ) ) { // some backends store headers/metadata
                    $val['xattr'] = self::normalizeXAttributes( $val['xattr'] );
                    $this->cheapCache->set( $path, 'xattr',
                        [ 'map' => $val['xattr'], 'latest' => false ] );
                }
            }
        }
    }
 
    final protected static function normalizeXAttributes( array $xattr ) {
        $newXAttr = [ 'headers' => [], 'metadata' => [] ];
 
        foreach ( $xattr['headers'] as $name => $value ) {
            $newXAttr['headers'][strtolower( $name )] = $value;
        }
 
        foreach ( $xattr['metadata'] as $name => $value ) {
            $newXAttr['metadata'][strtolower( $name )] = $value;
        }
 
        return $newXAttr;
    }
 
    final protected function setConcurrencyFlags( array $opts ) {
        $opts['concurrency'] = 1; // off
        if ( $this->parallelize === 'implicit' ) {
            if ( !isset( $opts['parallelize'] ) || $opts['parallelize'] ) {
                $opts['concurrency'] = $this->concurrency;
            }
        } elseif ( $this->parallelize === 'explicit' ) {
            if ( !empty( $opts['parallelize'] ) ) {
                $opts['concurrency'] = $this->concurrency;
            }
        }
 
        return $opts;
    }
 
    protected function getContentType( $storagePath, $content, $fsPath ) {
        if ( $this->mimeCallback ) {
            return call_user_func_array( $this->mimeCallback, func_get_args() );
        }
 
        $mime = null;
        if ( $fsPath !== null && function_exists( 'finfo_file' ) ) {
            $finfo = finfo_open( FILEINFO_MIME_TYPE );
            $mime = finfo_file( $finfo, $fsPath );
            finfo_close( $finfo );
        }
 
        return is_string( $mime ) ? $mime : 'unknown/unknown';
    }
}
 
abstract class FileBackendStoreOpHandle {
    public $params = []; // params to caller functions
    public $backend;
    public $resourcesToClose = [];
 
    public $call; // string; name that identifies the function called
 
    public function closeResources() {
        array_map( 'fclose', $this->resourcesToClose );
    }
}
 
abstract class FileBackendStoreShardListIterator extends FilterIterator {
    protected $backend;
 
    protected $params;
 
    protected $container;
 
    protected $directory;
 
    protected $multiShardPaths = []; // (rel path => 1)
 
    public function __construct(
        FileBackendStore $backend, $container, $dir, array $suffixes, array $params
    ) {
        $this->backend = $backend;
        $this->container = $container;
        $this->directory = $dir;
        $this->params = $params;
 
        $iter = new AppendIterator();
        foreach ( $suffixes as $suffix ) {
            $iter->append( $this->listFromShard( $this->container . $suffix ) );
        }
 
        parent::__construct( $iter );
    }
 
    public function accept() {
        $rel = $this->getInnerIterator()->current(); // path relative to given directory
        $path = $this->params['dir'] . "/{$rel}"; // full storage path
        if ( $this->backend->isSingleShardPathInternal( $path ) ) {
            return true; // path is only on one shard; no issue with duplicates
        } elseif ( isset( $this->multiShardPaths[$rel] ) ) {
            // Don't keep listing paths that are on multiple shards
            return false;
        } else {
            $this->multiShardPaths[$rel] = 1;
 
            return true;
        }
    }
 
    public function rewind() {
        parent::rewind();
        $this->multiShardPaths = [];
    }
 
    abstract protected function listFromShard( $container );
}
 
class FileBackendStoreShardDirIterator extends FileBackendStoreShardListIterator {
    protected function listFromShard( $container ) {
        $list = $this->backend->getDirectoryListInternal(
            $container, $this->directory, $this->params );
        if ( $list === null ) {
            return new ArrayIterator( [] );
        } else {
            return is_array( $list ) ? new ArrayIterator( $list ) : $list;
        }
    }
}
 
class FileBackendStoreShardFileIterator extends FileBackendStoreShardListIterator {
    protected function listFromShard( $container ) {
        $list = $this->backend->getFileListInternal(
            $container, $this->directory, $this->params );
        if ( $list === null ) {
            return new ArrayIterator( [] );
        } else {
            return is_array( $list ) ? new ArrayIterator( $list ) : $list;
        }
    }
}