LBFactoryMulti.php

Go to the documentation of this file.

<?php
namespace Wikimedia\Rdbms;
 
use InvalidArgumentException;
use UnexpectedValueException;
 
class LBFactoryMulti extends LBFactory {
    private $mainLBs = [];
    private $externalLBs = [];
 
    private $hostsByName = [];
    private $sectionsByDB = [];
    private $groupLoadsBySection = [];
    private $groupLoadsByDB = [];
    private $externalLoads = [];
    private $serverTemplate = [];
    private $externalTemplateOverrides = [];
    private $templateOverridesBySection = [];
    private $templateOverridesByCluster = [];
    private $masterTemplateOverrides = [];
    private $templateOverridesByServer = [];
    private $readOnlyBySection = [];
 
    private $loadMonitorClass;
 
    private $lastDomain;
    private $lastSection;
 
    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->externalLoads = $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'] ?? [];
 
        $this->loadMonitorClass = $conf['loadMonitorClass'] ?? LoadMonitor::class;
    }
 
    public function newMainLB( $domain = false, $owner = null ) {
        $section = $this->getSectionForDomain( $domain );
        if ( !isset( $this->groupLoadsBySection[$section][ILoadBalancer::GROUP_GENERIC] ) ) {
            throw new UnexpectedValueException( "Section '$section' has no hosts defined." );
        }
 
        $dbGroupLoads = $this->groupLoadsByDB[$this->getDomainDatabase( $domain )] ?? [];
        unset( $dbGroupLoads[ILoadBalancer::GROUP_GENERIC] ); // cannot override
 
        return $this->newLoadBalancer(
            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 ) {
        $section = $this->getSectionForDomain( $domain );
 
        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->externalLoads[$cluster] ) ) {
            throw new InvalidArgumentException( "Unknown cluster '$cluster'" );
        }
 
        return $this->newLoadBalancer(
            array_merge(
                $this->serverTemplate,
                $this->externalTemplateOverrides,
                $this->templateOverridesByCluster[$cluster] ?? []
            ),
            [ ILoadBalancer::GROUP_GENERIC => $this->externalLoads[$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->externalLoads 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 getSectionForDomain( $domain = false ) {
        if ( $this->lastDomain === $domain ) {
            return $this->lastSection;
        }
 
        $database = $this->getDomainDatabase( $domain );
        $section = $this->sectionsByDB[$database] ?? self::CLUSTER_MAIN_DEFAULT;
        $this->lastSection = $section;
        $this->lastDomain = $domain;
 
        return $section;
    }
 
    private function newLoadBalancer( $serverTemplate, $groupLoads, $readOnlyReason, $owner ) {
        $lb = new LoadBalancer( array_merge(
            $this->baseLoadBalancerParams( $owner ),
            [
                'servers' => $this->makeServerArray( $serverTemplate, $groupLoads ),
                'loadMonitor' => [ 'class' => $this->loadMonitorClass ],
                'readOnlyReason' => $readOnlyReason
            ]
        ) );
        $this->initLoadBalancer( $lb );
 
        return $lb;
    }
 
    private function makeServerArray( 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->reindexGroupLoads( $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 reindexGroupLoads( array $groupLoads ) {
        $reindexed = [];
 
        foreach ( $groupLoads as $group => $loadByHost ) {
            foreach ( $loadByHost as $host => $load ) {
                $reindexed[$host][$group] = $load;
            }
        }
 
        return $reindexed;
    }
 
    private function getDomainDatabase( $domain = false ) {
        return ( $domain === false )
            ? $this->localDomain->getDatabase()
            : DatabaseDomain::newFromId( $domain )->getDatabase();
    }
}