ExternalStoreFactory.php

Go to the documentation of this file.

<?php
use MediaWiki\MediaWikiServices;
use Psr\Log\LoggerAwareInterface;
use Psr\Log\LoggerInterface;
use Psr\Log\NullLogger;
use Wikimedia\Assert\Assert;
 
class ExternalStoreFactory implements LoggerAwareInterface {
    private $protocols;
    private $writeBaseUrls;
    private $localDomainId;
    private $logger;
 
    public function __construct(
        array $externalStores,
        array $defaultStores,
        $localDomainId,
        LoggerInterface $logger = null
    ) {
        Assert::parameterType( 'string', $localDomainId, '$localDomainId' );
 
        $this->protocols = array_map( 'strtolower', $externalStores );
        $this->writeBaseUrls = $defaultStores;
        $this->localDomainId = $localDomainId;
        $this->logger = $logger ?: new NullLogger();
    }
 
    public function setLogger( LoggerInterface $logger ) {
        $this->logger = $logger;
    }
 
    public function getProtocols() {
        return $this->protocols;
    }
 
    public function getWriteBaseUrls() {
        return $this->writeBaseUrls;
    }
 
    public function getStore( $proto, array $params = [] ) {
        $protoLowercase = strtolower( $proto ); // normalize
        if ( !$this->protocols || !in_array( $protoLowercase, $this->protocols ) ) {
            throw new ExternalStoreException( "Protocol '$proto' is not enabled." );
        }
 
        $class = 'ExternalStore' . ucfirst( $proto );
        if ( isset( $params['wiki'] ) ) {
            $params += [ 'domain' => $params['wiki'] ]; // b/c
        }
        if ( !isset( $params['domain'] ) || $params['domain'] === false ) {
            $params['domain'] = $this->localDomainId; // default
            $params['isDomainImplicit'] = true; // b/c for ExternalStoreDB
        }
        // @TODO: ideally, this class should not hardcode what classes need what backend factory
        // objects. For now, inject the factory instances into __construct() for those that do.
        if ( $protoLowercase === 'db' ) {
            $params['lbFactory'] = MediaWikiServices::getInstance()->getDBLoadBalancerFactory();
        } elseif ( $protoLowercase === 'mwstore' ) {
            $params['fbGroup'] = FileBackendGroup::singleton();
        }
        $params['logger'] = $this->logger;
 
        if ( !class_exists( $class ) ) {
            throw new ExternalStoreException( "Class '$class' is not defined." );
        }
 
        // Any custom modules should be added to $wgAutoLoadClasses for on-demand loading
        return new $class( $params );
    }
 
    public function getStoreForUrl( $url, array $params = [] ) {
        list( $proto, $path ) = self::splitStorageUrl( $url );
        if ( $path == '' ) { // bad URL
            throw new ExternalStoreException( "Invalid URL '$url'" );
        }
 
        return $this->getStore( $proto, $params );
    }
 
    public function getStoreLocationFromUrl( $url ) {
        list( , $location ) = self::splitStorageUrl( $url );
        if ( $location == '' ) { // bad URL
            throw new ExternalStoreException( "Invalid URL '$url'" );
        }
 
        return $location;
    }
 
    public function getUrlsByProtocol( array $urls ) {
        $urlsByProtocol = [];
        foreach ( $urls as $url ) {
            list( $proto, ) = self::splitStorageUrl( $url );
            $urlsByProtocol[$proto][] = $url;
        }
 
        return $urlsByProtocol;
    }
 
    private static function splitStorageUrl( $storeUrl ) {
        $parts = explode( '://', $storeUrl );
        if ( count( $parts ) != 2 || $parts[0] === '' || $parts[1] === '' ) {
            throw new ExternalStoreException( "Invalid storage URL '$storeUrl'" );
        }
 
        return $parts;
    }
}