LBFactory.php

Go to the documentation of this file.

<?php
abstract class LBFactory {
    protected static $instance;

    public static function disableBackend() {
        global $wgLBFactoryConf;
        self::$instance = new LBFactoryFake( $wgLBFactoryConf );
    }

    static function &singleton() {
        global $wgLBFactoryConf;

        if ( is_null( self::$instance ) ) {
            $class = self::getLBFactoryClass( $wgLBFactoryConf );

            self::$instance = new $class( $wgLBFactoryConf );
        }

        return self::$instance;
    }

    public static function getLBFactoryClass( array $config ) {
        // For configuration backward compatibility after removing
        // underscores from class names in MediaWiki 1.23.
        $bcClasses = array(
            'LBFactory_Simple' => 'LBFactorySimple',
            'LBFactory_Single' => 'LBFactorySingle',
            'LBFactory_Multi' => 'LBFactoryMulti',
            'LBFactory_Fake' => 'LBFactoryFake',
        );

        $class = $config['class'];

        if ( isset( $bcClasses[$class] ) ) {
            $class = $bcClasses[$class];
            wfDeprecated(
                '$wgLBFactoryConf must be updated. See RELEASE-NOTES for details',
                '1.23'
            );
        }

        return $class;
    }

    static function destroyInstance() {
        if ( self::$instance ) {
            self::$instance->shutdown();
            self::$instance->forEachLBCallMethod( 'closeAll' );
            self::$instance = null;
        }
    }

    static function setInstance( $instance ) {
        self::destroyInstance();
        self::$instance = $instance;
    }

    abstract function __construct( $conf );

    abstract function newMainLB( $wiki = false );

    abstract function getMainLB( $wiki = false );

    abstract function newExternalLB( $cluster, $wiki = false );

    abstract function &getExternalLB( $cluster, $wiki = false );

    abstract function forEachLB( $callback, $params = array() );

    function shutdown() {
    }

    function forEachLBCallMethod( $methodName, $args = array() ) {
        $this->forEachLB( array( $this, 'callMethod' ), array( $methodName, $args ) );
    }

    function callMethod( $loadBalancer, $methodName, $args ) {
        call_user_func_array( array( $loadBalancer, $methodName ), $args );
    }

    function commitMasterChanges() {
        $this->forEachLBCallMethod( 'commitMasterChanges' );
    }

    function rollbackMasterChanges() {
        $this->forEachLBCallMethod( 'rollbackMasterChanges' );
    }

    function hasMasterChanges() {
        $ret = false;
        $this->forEachLB( function ( $lb ) use ( &$ret ) {
            $ret = $ret || $lb->hasMasterChanges();
        } );
        return $ret;
    }
}

class LBFactorySimple extends LBFactory {
    protected $mainLB;

    protected $extLBs = array();

    protected $chronProt;

    function __construct( $conf ) {
        $this->chronProt = new ChronologyProtector;
    }

    function newMainLB( $wiki = false ) {
        global $wgDBservers, $wgMasterWaitTimeout;
        if ( $wgDBservers ) {
            $servers = $wgDBservers;
        } else {
            global $wgDBserver, $wgDBuser, $wgDBpassword, $wgDBname, $wgDBtype, $wgDebugDumpSql;
            global $wgDBssl, $wgDBcompress;

            $flags = DBO_DEFAULT;
            if ( $wgDebugDumpSql ) {
                $flags |= DBO_DEBUG;
            }
            if ( $wgDBssl ) {
                $flags |= DBO_SSL;
            }
            if ( $wgDBcompress ) {
                $flags |= DBO_COMPRESS;
            }

            $servers = array( array(
                'host' => $wgDBserver,
                'user' => $wgDBuser,
                'password' => $wgDBpassword,
                'dbname' => $wgDBname,
                'type' => $wgDBtype,
                'load' => 1,
                'flags' => $flags
            ) );
        }

        return new LoadBalancer( array(
            'servers' => $servers,
            'masterWaitTimeout' => $wgMasterWaitTimeout
        ) );
    }

    function getMainLB( $wiki = false ) {
        if ( !isset( $this->mainLB ) ) {
            $this->mainLB = $this->newMainLB( $wiki );
            $this->mainLB->parentInfo( array( 'id' => 'main' ) );
            $this->chronProt->initLB( $this->mainLB );
        }

        return $this->mainLB;
    }

    function newExternalLB( $cluster, $wiki = false ) {
        global $wgExternalServers;
        if ( !isset( $wgExternalServers[$cluster] ) ) {
            throw new MWException( __METHOD__ . ": Unknown cluster \"$cluster\"" );
        }

        return new LoadBalancer( array(
            'servers' => $wgExternalServers[$cluster]
        ) );
    }

    function &getExternalLB( $cluster, $wiki = false ) {
        if ( !isset( $this->extLBs[$cluster] ) ) {
            $this->extLBs[$cluster] = $this->newExternalLB( $cluster, $wiki );
            $this->extLBs[$cluster]->parentInfo( array( 'id' => "ext-$cluster" ) );
            $this->chronProt->initLB( $this->extLBs[$cluster] );
        }

        return $this->extLBs[$cluster];
    }

    function forEachLB( $callback, $params = array() ) {
        if ( isset( $this->mainLB ) ) {
            call_user_func_array( $callback, array_merge( array( $this->mainLB ), $params ) );
        }
        foreach ( $this->extLBs as $lb ) {
            call_user_func_array( $callback, array_merge( array( $lb ), $params ) );
        }
    }

    function shutdown() {
        if ( $this->mainLB ) {
            $this->chronProt->shutdownLB( $this->mainLB );
        }
        foreach ( $this->extLBs as $extLB ) {
            $this->chronProt->shutdownLB( $extLB );
        }
        $this->chronProt->shutdown();
        $this->commitMasterChanges();
    }
}

class LBFactoryFake extends LBFactory {
    function __construct( $conf ) {
    }

    function newMainLB( $wiki = false ) {
        throw new DBAccessError;
    }

    function getMainLB( $wiki = false ) {
        throw new DBAccessError;
    }

    function newExternalLB( $cluster, $wiki = false ) {
        throw new DBAccessError;
    }

    function &getExternalLB( $cluster, $wiki = false ) {
        throw new DBAccessError;
    }

    function forEachLB( $callback, $params = array() ) {
    }
}

class DBAccessError extends MWException {
    function __construct() {
        parent::__construct( "Mediawiki tried to access the database via wfGetDB(). " .
            "This is not allowed." );
    }
}