LBFactory.php

Go to the documentation of this file.

<?php
abstract class LBFactory {

    static $instance;

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

    static function &singleton() {
        if ( is_null( self::$instance ) ) {
            global $wgLBFactoryConf;
            $class = $wgLBFactoryConf['class'];
            self::$instance = new $class( $wgLBFactoryConf );
        }
        return self::$instance;
    }

    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' );
    }
}

class LBFactory_Simple extends LBFactory {

    var $mainLB;
    var $extLBs = array();

    # Chronology protector
    var $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 = ( $wgDebugDumpSql ? DBO_DEBUG : 0 ) | DBO_DEFAULT;
            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 LBFactory_Fake 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." );
    }
}