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 $hostsByName;
    private $sectionsByDB;
    private $groupLoadsBySection;
    private $groupLoadsByDB;
    private $externalLoadsByCluster;
    private $serverTemplate;
    private $externalTemplateOverrides;
    private $templateOverridesBySection;
    private $templateOverridesByCluster;
    private $masterTemplateOverrides;
    private $templateOverridesByServer;
    private $readOnlyBySection;
    private $loadMonitorConfig;
 
    public function __construct( array $conf ) {
        parent::__construct( $conf );
 
        $this->hostsByName = $conf['hostsByName'] ?? [];
        $this->sectionsByDB = $conf['sectionsByDB'];
        $this->groupLoadsBySection = $conf['groupLoadsBySection'] ?? [];
        foreach ( ( $conf['sectionLoads'] ?? [] ) as $section => $loadByHost ) {
            $this->groupLoadsBySection[$section][ILoadBalancer::GROUP_GENERIC] = $loadByHost;
        }
        $this->groupLoadsByDB = $conf['groupLoadsByDB'] ?? [];
        $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 ( array_keys( $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, $owner = null ) {
        $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." );
        }
 
        $dbGroupLoads = $this->groupLoadsByDB[$database] ?? [];
        unset( $dbGroupLoads[ILoadBalancer::GROUP_GENERIC] ); // cannot override
        return $this->newLoadBalancer(
            $section,
            array_merge(
                $this->serverTemplate,
                $this->templateOverridesBySection[$section] ?? []
            ),
            array_merge( $this->groupLoadsBySection[$section], $dbGroupLoads ),
            // Use the LB-specific read-only reason if everything isn't already read-only
            is_string( $this->readOnlyReason )
                ? $this->readOnlyReason
                : ( $this->readOnlyBySection[$section] ?? false ),
            $owner
        );
    }
 
    public function getMainLB( $domain = false ) {
        $domainInstance = $this->resolveDomainInstance( $domain );
        $section = $this->getSectionFromDatabase( $domainInstance->getDatabase() );
 
        if ( !isset( $this->mainLBs[$section] ) ) {
            $this->mainLBs[$section] = $this->newMainLB( $domain, $this->getOwnershipId() );
        }
 
        return $this->mainLBs[$section];
    }
 
    public function newExternalLB( $cluster, $owner = null ) {
        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,
            $owner
        );
    }
 
    public function getExternalLB( $cluster ) {
        if ( !isset( $this->externalLBs[$cluster] ) ) {
            $this->externalLBs[$cluster] = $this->newExternalLB(
                $cluster,
                $this->getOwnershipId()
            );
        }
 
        return $this->externalLBs[$cluster];
    }
 
    public function getAllMainLBs() {
        $lbs = [];
        foreach ( $this->sectionsByDB as $db => $section ) {
            if ( !isset( $lbs[$section] ) ) {
                $lbs[$section] = $this->getMainLB( $db );
            }
        }
 
        return $lbs;
    }
 
    public function getAllExternalLBs() {
        $lbs = [];
        foreach ( $this->externalLoadsByCluster as $cluster => $unused ) {
            $lbs[$cluster] = $this->getExternalLB( $cluster );
        }
 
        return $lbs;
    }
 
    public function forEachLB( $callback, array $params = [] ) {
        foreach ( $this->mainLBs as $lb ) {
            $callback( $lb, ...$params );
        }
        foreach ( $this->externalLBs as $lb ) {
            $callback( $lb, ...$params );
        }
    }
 
    private function newLoadBalancer(
        string $clusterName,
        array $serverTemplate,
        array $groupLoads,
        $readOnlyReason,
        $owner
    ) {
        $lb = new LoadBalancer( array_merge(
            $this->baseLoadBalancerParams( $owner ),
            [
                '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 master 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 master defined." );
        }
        $groupLoadsByHost = $this->reindexGroupLoadsByHost( $groupLoads );
        // Get the ordered map of (host => load); the master server is first
        $genericLoads = $groupLoads[ILoadBalancer::GROUP_GENERIC];
        // Implictly append any hosts that only appear in custom load groups
        $genericLoads += array_fill_keys( array_keys( $groupLoadsByHost ), 0 );
        $servers = [];
        foreach ( $genericLoads as $host => $load ) {
            $servers[] = array_merge(
                $serverTemplate,
                $servers ? [] : $this->masterTemplateOverrides,
                $this->templateOverridesByServer[$host] ?? [],
                [
                    'host' => $this->hostsByName[$host] ?? $host,
                    'hostName' => $host,
                    'load' => $load,
                    'groupLoads' => $groupLoadsByHost[$host] ?? []
                ]
            );
        }
 
        return $servers;
    }
 
    private function reindexGroupLoadsByHost( $groupLoads ) {
        $groupLoadsByHost = [];
        foreach ( $groupLoads as $group => $loadByHost ) {
            foreach ( $loadByHost as $host => $load ) {
                $groupLoadsByHost[$host][$group] = $load;
            }
        }
 
        return $groupLoadsByHost;
    }
 
    private function getSectionFromDatabase( $database ) {
        return $this->sectionsByDB[$database] ?? self::CLUSTER_MAIN_DEFAULT;
    }
}