LBFactoryMulti.php

Go to the documentation of this file.

<?php
namespace Wikimedia\Rdbms;
 
use InvalidArgumentException;
use LogicException;
use UnexpectedValueException;
 
class LBFactoryMulti extends LBFactory {
    private $mainLBs = [];
    private $externalLBs = [];
 
    private $hostsByServerName;
    private $sectionsByDB;
    private $groupLoadsBySection;
    private $externalLoadsByCluster;
    private $serverTemplate;
    private $externalTemplateOverrides;
    private $templateOverridesBySection;
    private $templateOverridesByCluster;
    private $masterTemplateOverrides;
    private $templateOverridesByServer;
    private $readOnlyBySection;
    private $loadMonitorConfig;
    private $nonLocalDomainCache = [];
 
    public function __construct( array $conf ) {
        parent::__construct( $conf );
 
        $this->hostsByServerName = $conf['hostsByName'] ?? [];
        $this->sectionsByDB = $conf['sectionsByDB'];
        $this->sectionsByDB += [ self::CLUSTER_MAIN_DEFAULT => self::CLUSTER_MAIN_DEFAULT ];
        $this->groupLoadsBySection = $conf['groupLoadsBySection'] ?? [];
        foreach ( ( $conf['sectionLoads'] ?? [] ) as $section => $loadsByServerName ) {
            $this->groupLoadsBySection[$section][ILoadBalancer::GROUP_GENERIC] = $loadsByServerName;
        }
        $this->externalLoadsByCluster = $conf['externalLoads'] ?? [];
        $this->serverTemplate = $conf['serverTemplate'] ?? [];
        $this->externalTemplateOverrides = $conf['externalTemplateOverrides'] ?? [];
        $this->templateOverridesBySection = $conf['templateOverridesBySection'] ?? [];
        $this->templateOverridesByCluster = $conf['templateOverridesByCluster'] ?? [];
        $this->masterTemplateOverrides = $conf['masterTemplateOverrides'] ?? [];
        $this->templateOverridesByServer = $conf['templateOverridesByServer'] ?? [];
        $this->readOnlyBySection = $conf['readOnlyBySection'] ?? [];
 
        if ( isset( $conf['loadMonitor'] ) ) {
            $this->loadMonitorConfig = $conf['loadMonitor'];
        } elseif ( isset( $conf['loadMonitorClass'] ) ) { // b/c
            $this->loadMonitorConfig = [ 'class' => $conf['loadMonitorClass'] ];
        } else {
            $this->loadMonitorConfig = [ 'class' => LoadMonitor::class ];
        }
 
        foreach ( $this->externalLoadsByCluster as $cluster => $_ ) {
            if ( isset( $this->groupLoadsBySection[$cluster] ) ) {
                throw new LogicException(
                    "External cluster '$cluster' has the same name as a main section/cluster"
                );
            }
        }
    }
 
    public function newMainLB( $domain = false ): ILoadBalancerForOwner {
        $domainInstance = $this->resolveDomainInstance( $domain );
        $database = $domainInstance->getDatabase();
        $section = $this->getSectionFromDatabase( $database );
 
        if ( !isset( $this->groupLoadsBySection[$section][ILoadBalancer::GROUP_GENERIC] ) ) {
            throw new UnexpectedValueException( "Section '$section' has no hosts defined." );
        }
 
        return $this->newLoadBalancer(
            $section,
            array_merge(
                $this->serverTemplate,
                $this->templateOverridesBySection[$section] ?? []
            ),
            $this->groupLoadsBySection[$section],
            // Use the LB-specific read-only reason if everything isn't already read-only
            is_string( $this->readOnlyReason )
                ? $this->readOnlyReason
                : ( $this->readOnlyBySection[$section] ?? false )
        );
    }
 
    private function resolveDomainInstance( $domain ) {
        if ( $domain instanceof DatabaseDomain ) {
            return $domain; // already a domain instance
        } elseif ( $domain === false || $domain === $this->localDomain->getId() ) {
            return $this->localDomain;
        } elseif ( isset( $this->domainAliases[$domain] ) ) {
            // This array acts as both the original map and as instance cache.
            // Instances pass-through DatabaseDomain::newFromId as-is.
            $this->domainAliases[$domain] =
                DatabaseDomain::newFromId( $this->domainAliases[$domain] );
 
            return $this->domainAliases[$domain];
        }
 
        $cachedDomain = $this->nonLocalDomainCache[$domain] ?? null;
        if ( $cachedDomain === null ) {
            $cachedDomain = DatabaseDomain::newFromId( $domain );
            $this->nonLocalDomainCache = [ $domain => $cachedDomain ];
        }
 
        return $cachedDomain;
    }
 
    public function getMainLB( $domain = false ): ILoadBalancer {
        $domainInstance = $this->resolveDomainInstance( $domain );
        $section = $this->getSectionFromDatabase( $domainInstance->getDatabase() );
 
        if ( !isset( $this->mainLBs[$section] ) ) {
            $this->mainLBs[$section] = $this->newMainLB( $domain );
        }
 
        return $this->mainLBs[$section];
    }
 
    public function newExternalLB( $cluster ): ILoadBalancerForOwner {
        if ( !isset( $this->externalLoadsByCluster[$cluster] ) ) {
            throw new InvalidArgumentException( "Unknown cluster '$cluster'" );
        }
        return $this->newLoadBalancer(
            $cluster,
            array_merge(
                $this->serverTemplate,
                $this->externalTemplateOverrides,
                $this->templateOverridesByCluster[$cluster] ?? []
            ),
            [ ILoadBalancer::GROUP_GENERIC => $this->externalLoadsByCluster[$cluster] ],
            $this->readOnlyReason
        );
    }
 
    public function getExternalLB( $cluster ): ILoadBalancer {
        if ( !isset( $this->externalLBs[$cluster] ) ) {
            $this->externalLBs[$cluster] = $this->newExternalLB(
                $cluster
            );
        }
 
        return $this->externalLBs[$cluster];
    }
 
    public function getAllMainLBs(): array {
        $lbs = [];
        foreach ( $this->sectionsByDB as $db => $section ) {
            if ( !isset( $lbs[$section] ) ) {
                $lbs[$section] = $this->getMainLB( $db );
            }
        }
 
        return $lbs;
    }
 
    public function getAllExternalLBs(): array {
        $lbs = [];
        foreach ( $this->externalLoadsByCluster as $cluster => $unused ) {
            $lbs[$cluster] = $this->getExternalLB( $cluster );
        }
 
        return $lbs;
    }
 
    protected function getLBsForOwner() {
        foreach ( $this->mainLBs as $lb ) {
            yield $lb;
        }
        foreach ( $this->externalLBs as $lb ) {
            yield $lb;
        }
    }
 
    private function newLoadBalancer(
        string $clusterName,
        array $serverTemplate,
        array $groupLoads,
        $readOnlyReason
    ) {
        $lb = new LoadBalancer( array_merge(
            $this->baseLoadBalancerParams(),
            [
                'servers' => $this->makeServerConfigArrays( $serverTemplate, $groupLoads ),
                'loadMonitor' => $this->loadMonitorConfig,
                'readOnlyReason' => $readOnlyReason,
                'clusterName' => $clusterName
            ]
        ) );
        $this->initLoadBalancer( $lb );
 
        return $lb;
    }
 
    private function makeServerConfigArrays( array $serverTemplate, array $groupLoads ) {
        // The primary DB server is the first host explicitly listed in the generic load group
        if ( !$groupLoads[ILoadBalancer::GROUP_GENERIC] ) {
            throw new UnexpectedValueException( "Empty generic load array; no primary DB defined." );
        }
        $groupLoadsByServerName = [];
        foreach ( $groupLoads as $group => $loadByServerName ) {
            foreach ( $loadByServerName as $serverName => $load ) {
                $groupLoadsByServerName[$serverName][$group] = $load;
            }
        }
 
        // Get the ordered map of (server name => load); the primary DB server is first
        $genericLoads = $groupLoads[ILoadBalancer::GROUP_GENERIC];
        // Implicitly append any hosts that only appear in custom load groups
        $genericLoads += array_fill_keys( array_keys( $groupLoadsByServerName ), 0 );
        $servers = [];
        foreach ( $genericLoads as $serverName => $load ) {
            $servers[] = array_merge(
                $serverTemplate,
                $servers ? [] : $this->masterTemplateOverrides,
                $this->templateOverridesByServer[$serverName] ?? [],
                [
                    'host' => $this->hostsByServerName[$serverName] ?? $serverName,
                    'serverName' => $serverName,
                    'load' => $load,
                    'groupLoads' => $groupLoadsByServerName[$serverName] ?? []
                ]
            );
        }
 
        return $servers;
    }
 
    private function getSectionFromDatabase( $database ) {
        return $this->sectionsByDB[$database]
            ?? $this->sectionsByDB[self::CLUSTER_MAIN_DEFAULT]
            ?? self::CLUSTER_MAIN_DEFAULT;
    }
 
    public function reconfigure( array $conf ): void {
        if ( !$conf ) {
            return;
        }
 
        foreach ( $this->mainLBs as $lb ) {
            // Approximate what LBFactoryMulti::__construct does (T346365)
            $groupLoads = $conf['groupLoadsBySection'][$lb->getClusterName()] ?? [];
            $groupLoads[ILoadBalancer::GROUP_GENERIC] = $conf['sectionLoads'][$lb->getClusterName()];
            $config = [
                'servers' => $this->makeServerConfigArrays( $conf['serverTemplate'] ?? [], $groupLoads )
            ];
            $lb->reconfigure( $config );
 
        }
        foreach ( $this->externalLBs as $lb ) {
            $groupLoads = [
                ILoadBalancer::GROUP_GENERIC => $conf['externalLoads'][$lb->getClusterName()]
            ];
            $config = [
                'servers' => $this->makeServerConfigArrays( $conf['serverTemplate'] ?? [], $groupLoads )
            ];
            $lb->reconfigure( $config );
        }
    }
}