CreateExternalDomainsTask.php

Go to the documentation of this file.

<?php
 
namespace MediaWiki\Installer\Task;
 
use MediaWiki\ExternalStore\ExternalStoreDB;
use MediaWiki\ExternalStore\ExternalStoreFactory;
use MediaWiki\MediaWikiServices;
use MediaWiki\Status\Status;
use Wikimedia\Rdbms\DatabaseDomain;
use Wikimedia\Rdbms\ILoadBalancer;
use Wikimedia\Rdbms\LBFactory;
 
class CreateExternalDomainsTask extends Task {
    private $lbFactory;
 
    private $esFactory;
 
    public function getName() {
        return 'external-domains';
    }
 
    public function getDependencies() {
        return [ 'VirtualDomains', 'services' ];
    }
 
    public function execute(): Status {
        $this->initServices( $this->getServices() );
        $status = $this->createVirtualDomains();
        $status->merge( $this->createExternalStoreDomains() );
        return $status;
    }
 
    private function initServices( MediaWikiServices $services ) {
        $this->lbFactory = $services->getDBLoadBalancerFactory();
        $this->esFactory = $services->getExternalStoreFactory();
    }
 
    private function createVirtualDomains(): Status {
        $status = Status::newGood();
        foreach ( $this->getVirtualDomains() as $virtualDomain ) {
            if ( !$this->shouldDoShared()
                && $this->lbFactory->isSharedVirtualDomain( $virtualDomain )
            ) {
                $status->warning( 'config-skip-shared-domain', $virtualDomain );
                // Skip update of shared virtual domain
                continue;
            }
            if ( $this->lbFactory->isLocalDomain( $virtualDomain ) ) {
                // No need to create the main wiki domain
                continue;
            }
            $lb = $this->lbFactory->getLoadBalancer( $virtualDomain );
            $realDomainId = $this->lbFactory->getMappedDomain( $virtualDomain );
            $status->merge( $this->maybeCreateDomain( $lb, $realDomainId ) );
        }
 
        return $status;
    }
 
    private function createExternalStoreDomains(): Status {
        $status = Status::newGood();
        $localDomainId = $this->lbFactory->getLocalDomainID();
        foreach ( $this->esFactory->getWriteBaseUrls() as $url ) {
            $store = $this->esFactory->getStoreForUrl( $url );
            if ( $store instanceof ExternalStoreDB ) {
                $cluster = $store->getClusterForUrl( $url );
                if ( $cluster === null ) {
                    throw new \RuntimeException( "Invalid store url \"$url\"" );
                }
                $lb = $this->lbFactory->getExternalLB( $cluster );
                $domainId = $store->getDomainIdForCluster( $cluster );
                if ( $domainId !== false && $domainId !== $localDomainId && !$this->shouldDoShared() ) {
                    // Skip potentially shared domain
                    $status->warning( 'config-skip-shared-domain', "$cluster/$domainId" );
                    continue;
                }
                $status->merge( $this->maybeCreateDomain( $lb, $domainId ) );
 
                $conn = $lb->getMaintenanceConnectionRef( DB_PRIMARY, [], $domainId );
                $conn->setSchemaVars( $this->getContext()->getSchemaVars() );
                if ( !$conn->tableExists( $store->getTable( $cluster ), __METHOD__ ) ) {
                    $store->initializeTable( $cluster );
                }
            }
        }
        return $status;
    }
 
    private function maybeCreateDomain( $lb, $domainId ) {
        $databaseCreator = $this->getDatabaseCreator();
        if ( $domainId === false ) {
            $domainId = $this->lbFactory->getLocalDomainID();
        }
        $database = DatabaseDomain::newFromId( $domainId )->getDatabase();
        if ( !$databaseCreator->existsInLoadBalancer( $lb, $database ) ) {
            return $databaseCreator->createInLoadBalancer( $lb, $database );
        }
        return Status::newGood();
    }
 
    private function shouldDoShared() {
        return (bool)$this->getOption( 'Shared' );
    }
}