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;
                        $servers = array(array(
                                'host' => $wgDBserver,
                                'user' => $wgDBuser,
                                'password' => $wgDBpassword,
                                'dbname' => $wgDBname,
                                'type' => $wgDBtype,
                                'load' => 1,
                                'flags' => ($wgDebugDumpSql ? DBO_DEBUG : 0) | DBO_DEFAULT
                        ));
                }

                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" ) );
                }
                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 );
                }
                $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." );
        }
}

class ChronologyProtector {
        var $startupPos;
        var $shutdownPos = array();

        function initLB( $lb ) {
                if ( $this->startupPos === null ) {
                        if ( !empty( $_SESSION[__CLASS__] ) ) {
                                $this->startupPos = $_SESSION[__CLASS__];
                        }
                }
                if ( !$this->startupPos ) {
                        return;
                }
                $masterName = $lb->getServerName( 0 );

                if ( $lb->getServerCount() > 1 && !empty( $this->startupPos[$masterName] ) ) {
                        $info = $lb->parentInfo();
                        $pos = $this->startupPos[$masterName];
                        wfDebug( __METHOD__.": LB " . $info['id'] . " waiting for master pos $pos\n" );
                        $lb->waitFor( $this->startupPos[$masterName] );
                }
        }

        function shutdownLB( $lb ) {
                // Don't start a session, don't bother with non-replicated setups
                if ( strval( session_id() ) == '' || $lb->getServerCount() <= 1 ) {
                        return;
                }
                $masterName = $lb->getServerName( 0 );
                if ( isset( $this->shutdownPos[$masterName] ) ) {
                        // Already done
                        return;
                }
                // Only save the position if writes have been done on the connection
                $db = $lb->getAnyOpenConnection( 0 );
                $info = $lb->parentInfo();
                if ( !$db || !$db->doneWrites() ) {
                        wfDebug( __METHOD__.": LB {$info['id']}, no writes done\n" );
                        return;
                }
                $pos = $db->getMasterPos();
                wfDebug( __METHOD__.": LB {$info['id']} has master pos $pos\n" );
                $this->shutdownPos[$masterName] = $pos;
        }

        function shutdown() {
                if ( session_id() != '' && count( $this->shutdownPos ) ) {
                        wfDebug( __METHOD__.": saving master pos for " .
                                count( $this->shutdownPos ) . " master(s)\n" );
                        $_SESSION[__CLASS__] = $this->shutdownPos;
                }
        }
}