FileBackendDBRepoWrapper.php

Go to the documentation of this file.

<?php
use MediaWiki\Output\StreamFile;
use Wikimedia\FileBackend\FileBackend;
use Wikimedia\Rdbms\IDatabase;
 
class FileBackendDBRepoWrapper extends FileBackend {
    protected $backend;
    protected $repoName;
    protected $dbHandleFunc;
    protected $resolvedPathCache;
    protected $dbs;
 
    public function __construct( array $config ) {
        $backend = $config['backend'];
        $config['name'] = $backend->getName();
        $config['domainId'] = $backend->getDomainId();
        parent::__construct( $config );
        $this->backend = $config['backend'];
        $this->repoName = $config['repoName'];
        $this->dbHandleFunc = $config['dbHandleFactory'];
        $this->resolvedPathCache = new MapCacheLRU( 100 );
    }
 
    public function getInternalBackend() {
        return $this->backend;
    }
 
    public function getBackendPath( $path, $latest = true ) {
        $paths = $this->getBackendPaths( [ $path ], $latest );
        return current( $paths );
    }
 
    public function getBackendPaths( array $paths, $latest = true ) {
        $db = $this->getDB( $latest ? DB_PRIMARY : DB_REPLICA );
 
        // @TODO: batching
        $resolved = [];
        foreach ( $paths as $i => $path ) {
            if ( !$latest && $this->resolvedPathCache->hasField( $path, 'target', 10 ) ) {
                $resolved[$i] = $this->resolvedPathCache->getField( $path, 'target' );
                continue;
            }
 
            [ , $container ] = FileBackend::splitStoragePath( $path );
 
            if ( $container === "{$this->repoName}-public" ) {
                $name = basename( $path );
                if ( str_contains( $path, '!' ) ) {
                    $sha1 = $db->newSelectQueryBuilder()
                        ->select( 'oi_sha1' )
                        ->from( 'oldimage' )
                        ->where( [ 'oi_archive_name' => $name ] )
                        ->caller( __METHOD__ )->fetchField();
                } else {
                    $sha1 = $db->newSelectQueryBuilder()
                        ->select( 'img_sha1' )
                        ->from( 'image' )
                        ->where( [ 'img_name' => $name ] )
                        ->caller( __METHOD__ )->fetchField();
                }
                if ( $sha1 === null || !strlen( $sha1 ) ) {
                    $resolved[$i] = $path; // give up
                    continue;
                }
                $resolved[$i] = $this->getPathForSHA1( $sha1 );
                $this->resolvedPathCache->setField( $path, 'target', $resolved[$i] );
            } elseif ( $container === "{$this->repoName}-deleted" ) {
                $name = basename( $path ); // <hash>.<ext>
                $sha1 = substr( $name, 0, strpos( $name, '.' ) ); // ignore extension
                $resolved[$i] = $this->getPathForSHA1( $sha1 );
                $this->resolvedPathCache->setField( $path, 'target', $resolved[$i] );
            } else {
                $resolved[$i] = $path;
            }
        }
 
        $res = [];
        foreach ( $paths as $i => $path ) {
            $res[$i] = $resolved[$i];
        }
 
        return $res;
    }
 
    protected function doOperationsInternal( array $ops, array $opts ) {
        return $this->backend->doOperationsInternal( $this->mungeOpPaths( $ops ), $opts );
    }
 
    protected function doQuickOperationsInternal( array $ops, array $opts ) {
        return $this->backend->doQuickOperationsInternal( $this->mungeOpPaths( $ops ), $opts );
    }
 
    protected function doPrepare( array $params ) {
        return $this->backend->doPrepare( $params );
    }
 
    protected function doSecure( array $params ) {
        return $this->backend->doSecure( $params );
    }
 
    protected function doPublish( array $params ) {
        return $this->backend->doPublish( $params );
    }
 
    protected function doClean( array $params ) {
        return $this->backend->doClean( $params );
    }
 
    public function concatenate( array $params ) {
        return $this->translateSrcParams( __FUNCTION__, $params );
    }
 
    public function fileExists( array $params ) {
        return $this->translateSrcParams( __FUNCTION__, $params );
    }
 
    public function getFileTimestamp( array $params ) {
        return $this->translateSrcParams( __FUNCTION__, $params );
    }
 
    public function getFileSize( array $params ) {
        return $this->translateSrcParams( __FUNCTION__, $params );
    }
 
    public function getFileStat( array $params ) {
        return $this->translateSrcParams( __FUNCTION__, $params );
    }
 
    public function getFileXAttributes( array $params ) {
        return $this->translateSrcParams( __FUNCTION__, $params );
    }
 
    public function getFileSha1Base36( array $params ) {
        return $this->translateSrcParams( __FUNCTION__, $params );
    }
 
    public function getFileProps( array $params ) {
        return $this->translateSrcParams( __FUNCTION__, $params );
    }
 
    public function streamFile( array $params ) {
        // The stream methods use the file extension to determine the
        // Content-Type (as MediaWiki should already validate it on upload).
        // The translated SHA1 path has no extension, so this needs to use
        // the untranslated path extension.
        $type = StreamFile::contentTypeFromPath( $params['src'] );
        if ( $type && $type != 'unknown/unknown' ) {
            $params['headers'][] = "Content-type: $type";
        }
        return $this->translateSrcParams( __FUNCTION__, $params );
    }
 
    public function getFileContentsMulti( array $params ) {
        return $this->translateArrayResults( __FUNCTION__, $params );
    }
 
    public function getLocalReferenceMulti( array $params ) {
        return $this->translateArrayResults( __FUNCTION__, $params );
    }
 
    public function getLocalCopyMulti( array $params ) {
        return $this->translateArrayResults( __FUNCTION__, $params );
    }
 
    public function getFileHttpUrl( array $params ) {
        return $this->translateSrcParams( __FUNCTION__, $params );
    }
 
    public function directoryExists( array $params ) {
        return $this->backend->directoryExists( $params );
    }
 
    public function getDirectoryList( array $params ) {
        return $this->backend->getDirectoryList( $params );
    }
 
    public function getFileList( array $params ) {
        return $this->backend->getFileList( $params );
    }
 
    public function getFeatures() {
        return $this->backend->getFeatures();
    }
 
    public function clearCache( array $paths = null ) {
        $this->backend->clearCache( null ); // clear all
    }
 
    public function preloadCache( array $paths ) {
        $paths = $this->getBackendPaths( $paths );
        $this->backend->preloadCache( $paths );
    }
 
    public function preloadFileStat( array $params ) {
        return $this->translateSrcParams( __FUNCTION__, $params );
    }
 
    public function getScopedLocksForOps( array $ops, StatusValue $status ) {
        return $this->backend->getScopedLocksForOps( $ops, $status );
    }
 
    public function getPathForSHA1( $sha1 ) {
        if ( strlen( $sha1 ) < 3 ) {
            throw new InvalidArgumentException( "Invalid file SHA-1." );
        }
        return $this->backend->getContainerStoragePath( "{$this->repoName}-original" ) .
            "/{$sha1[0]}/{$sha1[1]}/{$sha1[2]}/{$sha1}";
    }
 
    protected function getDB( $index ) {
        if ( !isset( $this->dbs[$index] ) ) {
            $func = $this->dbHandleFunc;
            $this->dbs[$index] = $func( $index );
        }
        return $this->dbs[$index];
    }
 
    protected function translateSrcParams( $function, array $params ) {
        $latest = !empty( $params['latest'] );
 
        if ( isset( $params['src'] ) ) {
            $params['src'] = $this->getBackendPath( $params['src'], $latest );
        }
 
        if ( isset( $params['srcs'] ) ) {
            $params['srcs'] = $this->getBackendPaths( $params['srcs'], $latest );
        }
 
        return $this->backend->$function( $params );
    }
 
    protected function translateArrayResults( $function, array $params ) {
        $origPaths = $params['srcs'];
        $params['srcs'] = $this->getBackendPaths( $params['srcs'], !empty( $params['latest'] ) );
        $pathMap = array_combine( $params['srcs'], $origPaths );
 
        $results = $this->backend->$function( $params );
 
        $contents = [];
        foreach ( $results as $path => $result ) {
            $contents[$pathMap[$path]] = $result;
        }
 
        return $contents;
    }
 
    protected function mungeOpPaths( array $ops ) {
        // Ops that use 'src' and do not mutate core file data there
        static $srcRefOps = [ 'store', 'copy', 'describe' ];
        foreach ( $ops as &$op ) {
            if ( isset( $op['src'] ) && in_array( $op['op'], $srcRefOps ) ) {
                $op['src'] = $this->getBackendPath( $op['src'], true );
            }
            if ( isset( $op['srcs'] ) ) {
                $op['srcs'] = $this->getBackendPaths( $op['srcs'], true );
            }
        }
        return $ops;
    }
}