FileBackendStore.php

Go to the documentation of this file.

<?php
namespace Wikimedia\FileBackend;
 
use InvalidArgumentException;
use Shellbox\Command\BoxedCommand;
use StatusValue;
use Traversable;
use Wikimedia\FileBackend\FileIteration\FileBackendStoreShardDirIterator;
use Wikimedia\FileBackend\FileIteration\FileBackendStoreShardFileIterator;
use Wikimedia\FileBackend\FileOpHandle\FileBackendStoreOpHandle;
use Wikimedia\FileBackend\FileOps\CopyFileOp;
use Wikimedia\FileBackend\FileOps\CreateFileOp;
use Wikimedia\FileBackend\FileOps\DeleteFileOp;
use Wikimedia\FileBackend\FileOps\DescribeFileOp;
use Wikimedia\FileBackend\FileOps\FileOp;
use Wikimedia\FileBackend\FileOps\MoveFileOp;
use Wikimedia\FileBackend\FileOps\NullFileOp;
use Wikimedia\FileBackend\FileOps\StoreFileOp;
use Wikimedia\FileBackend\FSFile\FSFile;
use Wikimedia\LockManager\LockManager;
use Wikimedia\ObjectCache\BagOStuff;
use Wikimedia\ObjectCache\EmptyBagOStuff;
use Wikimedia\ObjectCache\MapCacheLRU;
use Wikimedia\ObjectCache\WANObjectCache;
use Wikimedia\Timestamp\ConvertibleTimestamp;
use Wikimedia\Timestamp\TimestampFormat as TS;
 
abstract class FileBackendStore extends FileBackend {
    protected WANObjectCache $wanCache;
    protected BagOStuff $srvCache;
    protected MapCacheLRU $cheapCache;
    protected MapCacheLRU $expensiveCache;
 
    protected WANObjectCache $wanStatCache;
    protected $memCache;
 
    protected $shardViaHashLevels = [];
 
    protected $mimeCallback;
 
    protected $maxFileSize = 32 * 1024 * 1024 * 1024;
 
    protected const CACHE_TTL = 10; // integer; TTL in seconds for process cache entries
    protected const CACHE_CHEAP_SIZE = 500; // integer; max entries in "cheap cache"
    protected const CACHE_EXPENSIVE_SIZE = 5; // integer; max entries in "expensive cache"
 
    protected const RES_ABSENT = false;
    protected const RES_ERROR = null;
 
    protected const ABSENT_NORMAL = 'FNE-N';
    protected const ABSENT_LATEST = 'FNE-L';
 
    public function __construct( array $config ) {
        parent::__construct( $config );
        $this->mimeCallback = $config['mimeCallback'] ?? null;
        $this->srvCache = $config['srvCache'] ?? new EmptyBagOStuff();
        $this->wanCache = $config['wanCache'] ?? WANObjectCache::newEmpty();
        $this->wanStatCache = WANObjectCache::newEmpty(); // disabled by default
        $this->memCache =& $this->wanStatCache; // compatability alias
        $this->cheapCache = new MapCacheLRU( self::CACHE_CHEAP_SIZE );
        $this->expensiveCache = new MapCacheLRU( self::CACHE_EXPENSIVE_SIZE );
    }
 
    final public function maxFileSizeInternal() {
        return min( $this->maxFileSize, PHP_INT_MAX );
    }
 
    abstract public function isPathUsableInternal( $storagePath );
 
    final public function createInternal( array $params ) {
        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 ( $params['dstExists'] ?? true ) {
                $this->deleteFileCache( $params['dst'] ); // persistent cache
            }
        }
 
        return $status;
    }
 
    abstract protected function doCreateInternal( array $params );
 
    final public function storeInternal( array $params ) {
        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 ( $params['dstExists'] ?? true ) {
                $this->deleteFileCache( $params['dst'] ); // persistent cache
            }
        }
 
        return $status;
    }
 
    abstract protected function doStoreInternal( array $params );
 
    final public function copyInternal( array $params ) {
        $status = $this->doCopyInternal( $params );
        $this->clearCache( [ $params['dst'] ] );
        if ( $params['dstExists'] ?? true ) {
            $this->deleteFileCache( $params['dst'] ); // persistent cache
        }
 
        return $status;
    }
 
    abstract protected function doCopyInternal( array $params );
 
    final public function deleteInternal( array $params ) {
        $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 ) {
        $status = $this->doMoveInternal( $params );
        $this->clearCache( [ $params['src'], $params['dst'] ] );
        $this->deleteFileCache( $params['src'] ); // persistent cache
        if ( $params['dstExists'] ?? true ) {
            $this->deleteFileCache( $params['dst'] ); // persistent cache
        }
 
        return $status;
    }
 
    abstract protected function doMoveInternal( array $params );
 
    final public function describeInternal( array $params ) {
        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 ) {
        $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...
            $hrStart = hrtime( true );
            $status->merge( $this->doConcatenate( $params ) );
            $sec = ( hrtime( true ) - $hrStart ) / 1e9;
            if ( !$status->isOK() ) {
                $this->logger->error( static::class . "-{$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'];
        unset( $params['latest'] );
 
        // Check that the specified temp file is valid...
        // phpcs:ignore Generic.PHP.NoSilencedErrors.Discouraged
        $ok = ( @is_file( $tmpPath ) && @filesize( $tmpPath ) == 0 );
        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(
                        $fsFile === self::RES_ERROR ? 'backend-fail-read' : 'backend-fail-notexists',
                        $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 ) {
        $status = $this->newStatus();
 
        [ $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." );
            [ , $shortCont, ] = self::splitStoragePath( $params['dir'] );
            foreach ( $this->getContainerSuffixes( $shortCont ) as $suffix ) {
                $status->merge( $this->doPrepareInternal( "{$fullCont}{$suffix}", $dir, $params ) );
            }
        }
 
        return $status;
    }
 
    protected function doPrepareInternal( $fullCont, $dirRel, array $params ) {
        return $this->newStatus();
    }
 
    final protected function doSecure( array $params ) {
        $status = $this->newStatus();
 
        [ $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." );
            [ , $shortCont, ] = self::splitStoragePath( $params['dir'] );
            foreach ( $this->getContainerSuffixes( $shortCont ) as $suffix ) {
                $status->merge( $this->doSecureInternal( "{$fullCont}{$suffix}", $dir, $params ) );
            }
        }
 
        return $status;
    }
 
    protected function doSecureInternal( $fullCont, $dirRel, array $params ) {
        return $this->newStatus();
    }
 
    final protected function doPublish( array $params ) {
        $status = $this->newStatus();
 
        [ $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." );
            [ , $shortCont, ] = self::splitStoragePath( $params['dir'] );
            foreach ( $this->getContainerSuffixes( $shortCont ) as $suffix ) {
                $status->merge( $this->doPublishInternal( "{$fullCont}{$suffix}", $dir, $params ) );
            }
        }
 
        return $status;
    }
 
    protected function doPublishInternal( $fullCont, $dirRel, array $params ) {
        return $this->newStatus();
    }
 
    final protected function doClean( array $params ) {
        $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)
            }
        }
 
        [ $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." );
            [ , $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( $fullCont, $dirRel, array $params ) {
        return $this->newStatus();
    }
 
    final public function fileExists( array $params ) {
        $stat = $this->getFileStat( $params );
        if ( is_array( $stat ) ) {
            return true;
        }
 
        return $stat === self::RES_ABSENT ? false : self::EXISTENCE_ERROR;
    }
 
    final public function getFileTimestamp( array $params ) {
        $stat = $this->getFileStat( $params );
        if ( is_array( $stat ) ) {
            return $stat['mtime'];
        }
 
        return self::TIMESTAMP_FAIL; // all failure cases
    }
 
    final public function getFileSize( array $params ) {
        $stat = $this->getFileStat( $params );
        if ( is_array( $stat ) ) {
            return $stat['size'];
        }
 
        return self::SIZE_FAIL; // all failure cases
    }
 
    final public function getFileStat( array $params ) {
        $path = self::normalizeStoragePath( $params['src'] );
        if ( $path === null ) {
            return self::STAT_ERROR; // invalid storage path
        }
 
        // Whether to bypass cache except for process cache entries loaded directly from
        // high consistency backend queries (caller handles any cache flushing and locking)
        $latest = !empty( $params['latest'] );
        // Whether to ignore cache entries missing the SHA-1 field for existing files
        $requireSHA1 = !empty( $params['requireSHA1'] );
 
        $stat = $this->cheapCache->getField( $path, 'stat', self::CACHE_TTL );
        // Load the persistent stat cache into process cache if needed
        if ( !$latest ) {
            if (
                // File stat is not in process cache
                $stat === null ||
                // Key/value store backends might opportunistically set file stat process
                // cache entries from object listings that do not include the SHA-1. In that
                // case, loading the persistent stat cache will likely yield the SHA-1.
                ( $requireSHA1 && is_array( $stat ) && !isset( $stat['sha1'] ) )
            ) {
                $this->primeFileCache( [ $path ] );
                // Get any newly process-cached entry
                $stat = $this->cheapCache->getField( $path, 'stat', self::CACHE_TTL );
            }
        }
 
        if ( is_array( $stat ) ) {
            if (
                ( !$latest || !empty( $stat['latest'] ) ) &&
                ( !$requireSHA1 || isset( $stat['sha1'] ) )
            ) {
                return $stat;
            }
        } elseif ( $stat === self::ABSENT_LATEST ) {
            return self::STAT_ABSENT;
        } elseif ( $stat === self::ABSENT_NORMAL ) {
            if ( !$latest ) {
                return self::STAT_ABSENT;
            }
        }
 
        // Load the file stat from the backend and update caches
        $stat = $this->doGetFileStat( $params );
        $this->ingestFreshFileStats( [ $path => $stat ], $latest );
 
        if ( is_array( $stat ) ) {
            return $stat;
        }
 
        return $stat === self::RES_ERROR ? self::STAT_ERROR : self::STAT_ABSENT;
    }
 
    final protected function ingestFreshFileStats( array $stats, $latest ) {
        $success = true;
 
        foreach ( $stats as $path => $stat ) {
            if ( is_array( $stat ) ) {
                // Strongly consistent backends might automatically set this flag
                $stat['latest'] ??= $latest;
 
                $this->cheapCache->setField( $path, 'stat', $stat );
                if ( isset( $stat['sha1'] ) ) {
                    // Some backends store the SHA-1 hash as metadata
                    $this->cheapCache->setField(
                        $path,
                        'sha1',
                        [ 'hash' => $stat['sha1'], 'latest' => $latest ]
                    );
                }
                if ( isset( $stat['xattr'] ) ) {
                    // Some backends store custom headers/metadata
                    $stat['xattr'] = self::normalizeXAttributes( $stat['xattr'] );
                    $this->cheapCache->setField(
                        $path,
                        'xattr',
                        [ 'map' => $stat['xattr'], 'latest' => $latest ]
                    );
                }
                // Update persistent cache (@TODO: set all entries in one batch)
                $this->setFileCache( $path, $stat );
            } elseif ( $stat === self::RES_ABSENT ) {
                $this->cheapCache->setField(
                    $path,
                    'stat',
                    $latest ? self::ABSENT_LATEST : self::ABSENT_NORMAL
                );
                $this->cheapCache->setField(
                    $path,
                    'xattr',
                    [ 'map' => self::XATTRS_FAIL, 'latest' => $latest ]
                );
                $this->cheapCache->setField(
                    $path,
                    'sha1',
                    [ 'hash' => self::SHA1_FAIL, 'latest' => $latest ]
                );
                $this->logger->debug(
                    __METHOD__ . ': File {path} does not exist',
                    [ 'path' => $path ]
                );
            } else {
                $success = false;
                $this->logger->error(
                    __METHOD__ . ': Could not stat file {path}',
                    [ 'path' => $path ]
                );
            }
        }
 
        return $success;
    }
 
    abstract protected function doGetFileStat( array $params );
 
    public function getFileContentsMulti( array $params ) {
        $params = $this->setConcurrencyFlags( $params );
        $contents = $this->doGetFileContentsMulti( $params );
        foreach ( $contents as $path => $content ) {
            if ( !is_string( $content ) ) {
                $contents[$path] = self::CONTENT_FAIL; // used for all failure cases
            }
        }
 
        return $contents;
    }
 
    protected function doGetFileContentsMulti( array $params ) {
        $contents = [];
        foreach ( $this->doGetLocalReferenceMulti( $params ) as $path => $fsFile ) {
            if ( $fsFile instanceof FSFile ) {
                // phpcs:ignore Generic.PHP.NoSilencedErrors.Discouraged
                $content = @file_get_contents( $fsFile->getPath() );
                $contents[$path] = is_string( $content ) ? $content : self::RES_ERROR;
            } else {
                // self::RES_ERROR or self::RES_ABSENT
                $contents[$path] = $fsFile;
            }
        }
 
        return $contents;
    }
 
    final public function getFileXAttributes( array $params ) {
        $path = self::normalizeStoragePath( $params['src'] );
        if ( $path === null ) {
            return self::XATTRS_FAIL; // invalid storage path
        }
        $latest = !empty( $params['latest'] ); // use latest data?
        if ( $this->cheapCache->hasField( $path, 'xattr', self::CACHE_TTL ) ) {
            $stat = $this->cheapCache->getField( $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 );
        if ( is_array( $fields ) ) {
            $fields = self::normalizeXAttributes( $fields );
            $this->cheapCache->setField(
                $path,
                'xattr',
                [ 'map' => $fields, 'latest' => $latest ]
            );
        } elseif ( $fields === self::RES_ABSENT ) {
            $this->cheapCache->setField(
                $path,
                'xattr',
                [ 'map' => self::XATTRS_FAIL, 'latest' => $latest ]
            );
        } else {
            $fields = self::XATTRS_FAIL; // used for all failure cases
        }
 
        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 self::SHA1_FAIL; // invalid storage path
        }
        $latest = !empty( $params['latest'] ); // use latest data?
        if ( $this->cheapCache->hasField( $path, 'sha1', self::CACHE_TTL ) ) {
            $stat = $this->cheapCache->getField( $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'];
            }
        }
        $sha1 = $this->doGetFileSha1Base36( $params );
        if ( is_string( $sha1 ) ) {
            $this->cheapCache->setField(
                $path,
                'sha1',
                [ 'hash' => $sha1, 'latest' => $latest ]
            );
        } elseif ( $sha1 === self::RES_ABSENT ) {
            $this->cheapCache->setField(
                $path,
                'sha1',
                [ 'hash' => self::SHA1_FAIL, 'latest' => $latest ]
            );
        } else {
            $sha1 = self::SHA1_FAIL; // used for all failure cases
        }
 
        return $sha1;
    }
 
    protected function doGetFileSha1Base36( array $params ) {
        $fsFile = $this->getLocalReference( $params );
        if ( $fsFile instanceof FSFile ) {
            $sha1 = $fsFile->getSha1Base36();
 
            return is_string( $sha1 ) ? $sha1 : self::RES_ERROR;
        }
 
        return $fsFile === self::RES_ERROR ? self::RES_ERROR : self::RES_ABSENT;
    }
 
    final public function getFileProps( array $params ) {
        $fsFile = $this->getLocalReference( $params );
 
        return $fsFile ? $fsFile->getProps() : FSFile::placeholderProps();
    }
 
    final public function getLocalReferenceMulti( array $params ) {
        $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] = self::RES_ERROR; // invalid storage path
            } elseif ( $this->expensiveCache->hasField( $path, 'localRef' ) ) {
                $val = $this->expensiveCache->getField( $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 remaining files...
        $params['srcs'] = array_diff( $params['srcs'], array_keys( $fsFiles ) );
        foreach ( $this->doGetLocalReferenceMulti( $params ) as $path => $fsFile ) {
            $fsFiles[$path] = $fsFile;
            if ( $fsFile instanceof FSFile ) {
                $this->expensiveCache->setField(
                    $path,
                    'localRef',
                    [ 'object' => $fsFile, 'latest' => $latest ]
                );
            }
        }
 
        return $fsFiles;
    }
 
    protected function doGetLocalReferenceMulti( array $params ) {
        return $this->doGetLocalCopyMulti( $params );
    }
 
    final public function getLocalCopyMulti( array $params ) {
        $params = $this->setConcurrencyFlags( $params );
 
        return $this->doGetLocalCopyMulti( $params );
    }
 
    abstract protected function doGetLocalCopyMulti( array $params );
 
    public function getFileHttpUrl( array $params ) {
        return self::TEMPURL_ERROR; // not supported
    }
 
    public function addShellboxInputFile( BoxedCommand $command, string $boxedName,
        array $params
    ) {
        $ref = $this->getLocalReference( [ 'src' => $params['src'] ] );
        if ( $ref === false ) {
            return $this->newStatus( 'backend-fail-notexists', $params['src'] );
        } elseif ( $ref === null ) {
            return $this->newStatus( 'backend-fail-read', $params['src'] );
        } else {
            $file = $command->newInputFileFromFile( $ref->getPath() )
                ->userData( __CLASS__, $ref );
            $command->inputFile( $boxedName, $file );
            return $this->newStatus();
        }
    }
 
    final public function streamFile( array $params ) {
        $status = $this->newStatus();
 
        // Always set some fields for subclass convenience
        $params['options'] ??= [];
        $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(),
                $this->getStreamerOptions()
            );
            $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 ) {
        [ $fullCont, $dir, $shard ] = $this->resolveStoragePath( $params['dir'] );
        if ( $dir === null ) {
            return self::EXISTENCE_ERROR; // 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." );
            [ , $shortCont, ] = self::splitStoragePath( $params['dir'] );
            $res = false; // response
            foreach ( $this->getContainerSuffixes( $shortCont ) as $suffix ) {
                $exists = $this->doDirectoryExists( "{$fullCont}{$suffix}", $dir, $params );
                if ( $exists === true ) {
                    $res = true;
                    break; // found one!
                } elseif ( $exists === self::RES_ERROR ) {
                    $res = self::EXISTENCE_ERROR;
                }
            }
 
            return $res;
        }
    }
 
    abstract protected function doDirectoryExists( $fullCont, $dirRel, array $params );
 
    final public function getDirectoryList( array $params ) {
        [ $fullCont, $dir, $shard ] = $this->resolveStoragePath( $params['dir'] );
        if ( $dir === null ) {
            return self::EXISTENCE_ERROR; // invalid storage path
        }
        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." );
            // File listing spans multiple containers/shards
            [ , $shortCont, ] = self::splitStoragePath( $params['dir'] );
 
            return new FileBackendStoreShardDirIterator( $this,
                $fullCont, $dir, $this->getContainerSuffixes( $shortCont ), $params );
        }
    }
 
    abstract public function getDirectoryListInternal( $fullCont, $dirRel, array $params );
 
    final public function getFileList( array $params ) {
        [ $fullCont, $dir, $shard ] = $this->resolveStoragePath( $params['dir'] );
        if ( $dir === null ) {
            return self::LIST_ERROR; // invalid storage path
        }
        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." );
            // File listing spans multiple containers/shards
            [ , $shortCont, ] = self::splitStoragePath( $params['dir'] );
 
            return new FileBackendStoreShardFileIterator( $this,
                $fullCont, $dir, $this->getContainerSuffixes( $shortCont ), $params );
        }
    }
 
    abstract public function getFileListInternal( $fullCont, $dirRel, array $params );
 
    final public function getOperationsInternal( array $ops ) {
        $supportedOps = [
            'store' => StoreFileOp::class,
            'copy' => CopyFileOp::class,
            'move' => MoveFileOp::class,
            'delete' => DeleteFileOp::class,
            'create' => CreateFileOp::class,
            'describe' => DescribeFileOp::class,
            'null' => NullFileOp::class
        ];
 
        $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 ) {
        $status = $this->newStatus();
 
        // Fix up custom header name/value pairs
        $ops = array_map( $this->sanitizeOpHeaders( ... ), $ops );
        // Build up a list of FileOps and involved paths
        $fileOps = $this->getOperationsInternal( $ops );
        $pathsUsed = [];
        foreach ( $fileOps as $fileOp ) {
            $pathsUsed = array_merge( $pathsUsed, $fileOp->storagePathsReadOrChanged() );
        }
 
        // Acquire any locks as needed for the scope of this function
        if ( empty( $opts['nonLocking'] ) ) {
            $pathsByLockType = $this->getPathsToLockForOpsInternal( $fileOps );
            $scopeLock = $this->getScopedFileLocks( $pathsByLockType, 'mixed', $status );
            if ( !$status->isOK() ) {
                return $status; // abort
            }
        }
 
        // Clear any file cache entries (after locks acquired)
        if ( empty( $opts['preserveCache'] ) ) {
            $this->clearCache( $pathsUsed );
        }
 
        // Enlarge the cache to fit the stat entries of these files
        $this->cheapCache->setMaxSize( max( 2 * count( $pathsUsed ), self::CACHE_CHEAP_SIZE ) );
 
        // Load from the persistent container caches
        $this->primeContainerCache( $pathsUsed );
        // Get the latest stat info for all the files (having locked them)
        $ok = $this->preloadFileStat( [ 'srcs' => $pathsUsed, 'latest' => true ] );
 
        if ( $ok ) {
            // Actually attempt the operation batch...
            $opts = $this->setConcurrencyFlags( $opts );
            $subStatus = FileOpBatch::attempt( $fileOps, $opts );
        } 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( static::class . "-{$this->name} stat failure",
                [ 'aborted_operations' => $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->setMaxSize( self::CACHE_CHEAP_SIZE );
 
        return $status;
    }
 
    final protected function doQuickOperationsInternal( array $ops, array $opts ) {
        $status = $this->newStatus();
 
        // Fix up custom header name/value pairs
        $ops = array_map( $this->sanitizeOpHeaders( ... ), $ops );
        // Build up a list of FileOps and involved paths
        $fileOps = $this->getOperationsInternal( $ops );
        $pathsUsed = [];
        foreach ( $fileOps as $fileOp ) {
            $pathsUsed = array_merge( $pathsUsed, $fileOp->storagePathsReadOrChanged() );
        }
 
        // Clear any file cache entries for involved paths
        $this->clearCache( $pathsUsed );
 
        // 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)
        $batch = [];
        foreach ( $fileOps as $index => $fileOp ) {
            $subStatus = $async
                ? $fileOp->attemptAsyncQuick()
                : $fileOp->attemptQuick();
            if ( $subStatus->value instanceof FileBackendStoreOpHandle ) { // async
                if ( count( $batch ) >= $maxConcurrency ) {
                    // Execute this batch. Don't queue any more ops since they contain
                    // open filehandles which are a limited resource (T230245).
                    $statuses += $this->executeOpHandlesInternal( $batch );
                    $batch = [];
                }
                $batch[$index] = $subStatus->value; // keep index
            } else { // error or completed
                $statuses[$index] = $subStatus; // keep index
            }
        }
        if ( count( $batch ) ) {
            $statuses += $this->executeOpHandlesInternal( $batch );
        }
        // 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;
            }
        }
 
        $this->clearCache( $pathsUsed );
 
        return $status;
    }
 
    final public function executeOpHandlesInternal( array $fileOpHandles ) {
        foreach ( $fileOpHandles as $fileOpHandle ) {
            if ( !( $fileOpHandle instanceof FileBackendStoreOpHandle ) ) {
                throw new InvalidArgumentException( "Expected FileBackendStoreOpHandle object." );
            } elseif ( $fileOpHandle->backend->getName() !== $this->getName() ) {
                throw new InvalidArgumentException( "Expected handle for this file backend." );
            }
        }
 
        $statuses = $this->doExecuteOpHandlesInternal( $fileOpHandles );
        foreach ( $fileOpHandles as $fileOpHandle ) {
            $fileOpHandle->closeResources();
        }
 
        return $statuses;
    }
 
    protected function doExecuteOpHandlesInternal( array $fileOpHandles ) {
        if ( count( $fileOpHandles ) ) {
            throw new FileBackendError( "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 ) {
                    $this->logger->error( "Header '{header}' is too long.", [
                        'filebackend' => $this->name,
                        'header' => "$name: $value",
                    ] );
                } 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 ) {
            [ $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 ) {
        $params['concurrency'] = ( $this->parallelize !== 'off' ) ? $this->concurrency : 1;
        $stats = $this->doGetFileStatMulti( $params );
        if ( $stats === null ) {
            return true; // not supported
        }
 
        // Whether this queried the backend in high consistency mode
        $latest = !empty( $params['latest'] );
 
        return $this->ingestFreshFileStats( $stats, $latest );
    }
 
    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.
        // 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 ) {
        [ $backend, $shortCont, $relPath ] = self::splitStoragePath( $storagePath );
        if ( $backend === $this->name && $relPath !== null ) { // 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 domain 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 ) {
        [ $container, $relPath, $cShard ] = $this->resolveStoragePath( $storagePath );
        if ( $cShard !== null && !str_ends_with( $relPath, '/' ) ) {
            return [ $container, $relPath ];
        }
 
        return [ null, null ];
    }
 
    final protected function getContainerShard( $container, $relPath ) {
        [ $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 ) {
        [ , , $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 = [];
        [ $digits, $base ] = $this->getContainerHashLevels( $container );
        if ( $digits > 0 ) {
            $numShards = $base ** $digits;
            for ( $index = 0; $index < $numShards; $index++ ) {
                $shards[] = '.' . \Wikimedia\base_convert( (string)$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 ) {
        if ( !$this->wanStatCache->set(
            $this->containerCacheKey( $container ),
            $val,
            14 * 86400
        ) ) {
            $this->logger->warning( "Unable to set stat cache for container {container}.",
                [ 'filebackend' => $this->name, 'container' => $container ]
            );
        }
    }
 
    final protected function deleteContainerCache( $container ) {
        if ( !$this->wanStatCache->delete( $this->containerCacheKey( $container ), 300 ) ) {
            $this->logger->warning( "Unable to delete stat cache for container {container}.",
                [ 'filebackend' => $this->name, 'container' => $container ]
            );
        }
    }
 
    final protected function primeContainerCache( array $items ) {
        $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 ) {
            [ $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->wanStatCache->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 = (int)ConvertibleTimestamp::convert( TS::UNIX, $val['mtime'] );
        $ttl = $this->wanStatCache->adaptiveTTL( $mtime, 7 * 86400, 300, 0.1 );
        // Set the cache unless it is currently salted.
        if ( !$this->wanStatCache->set( $this->fileCacheKey( $path ), $val, $ttl ) ) {
            $this->logger->warning( "Unable to set stat cache for file {path}.",
                [ 'filebackend' => $this->name, 'path' => $path ]
            );
        }
    }
 
    final protected function deleteFileCache( $path ) {
        $path = FileBackend::normalizeStoragePath( $path );
        if ( $path === null ) {
            return; // invalid storage path
        }
        if ( !$this->wanStatCache->delete( $this->fileCacheKey( $path ), 300 ) ) {
            $this->logger->warning( "Unable to delete stat cache for file {path}.",
                [ 'filebackend' => $this->name, 'path' => $path ]
            );
        }
    }
 
    final protected function primeFileCache( array $items ) {
        $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 ) ) {
                $path = FileBackend::normalizeStoragePath( $item );
                if ( $path !== null ) {
                    $paths[] = $path;
                }
            }
        }
        // Get all the corresponding cache keys for paths...
        foreach ( $paths as $path ) {
            [ , $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.
        // Note that negatives are not cached by getFileStat()/preloadFileStat().
        $values = $this->wanStatCache->getMulti( array_keys( $pathNames ) );
        // Load all of the results into process cache...
        foreach ( array_filter( $values, 'is_array' ) as $cacheKey => $stat ) {
            $path = $pathNames[$cacheKey];
            // This flag only applies to stat info loaded directly
            // from a high consistency backend query to the process cache
            unset( $stat['latest'] );
 
            $this->cheapCache->setField( $path, 'stat', $stat );
            if ( isset( $stat['sha1'] ) && strlen( $stat['sha1'] ) == 31 ) {
                // Some backends store SHA-1 as metadata
                $this->cheapCache->setField(
                    $path,
                    'sha1',
                    [ 'hash' => $stat['sha1'], 'latest' => false ]
                );
            }
            if ( isset( $stat['xattr'] ) && is_array( $stat['xattr'] ) ) {
                // Some backends store custom headers/metadata
                $stat['xattr'] = self::normalizeXAttributes( $stat['xattr'] );
                $this->cheapCache->setField(
                    $path,
                    'xattr',
                    [ 'map' => $stat['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 ( $opts['parallelize'] ?? true ) {
                $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 ( $this->mimeCallback )( $storagePath, $content, $fsPath );
        }
 
        $mime = ( $fsPath !== null ) ? mime_content_type( $fsPath ) : false;
        return $mime ?: 'unknown/unknown';
    }
}
 
class_alias( FileBackendStore::class, 'FileBackendStore' );