Refactored parser output handling slightly, and added a hook function, to allow exten...
[lhc/web/wiklou.git] / includes / LoadBalancer.php
index c3f87d4..cbee03e 100644 (file)
@@ -9,16 +9,6 @@
  */
 require_once( 'Database.php' );
 
-# Valid database indexes
-# Operation-based indexes
-define( 'DB_SLAVE', -1 );     # Read from the slave (or only server)
-define( 'DB_MASTER', -2 );    # Write to master (or only server)
-define( 'DB_LAST', -3 );     # Whatever database was used last
-
-# Obsolete aliases
-define( 'DB_READ', -1 );
-define( 'DB_WRITE', -2 );
-
 
 # Scale polling time so that under overload conditions, the database server
 # receives a SHOW STATUS query at an average interval of this many microseconds
@@ -34,29 +24,11 @@ define( 'AVG_STATUS_POLL', 2000 );
 class LoadBalancer {
        /* private */ var $mServers, $mConnections, $mLoads, $mGroupLoads;
        /* private */ var $mFailFunction, $mErrorConnection;
-       /* private */ var $mForce, $mReadIndex, $mLastIndex;
+       /* private */ var $mForce, $mReadIndex, $mLastIndex, $mAllowLagged;
        /* private */ var $mWaitForFile, $mWaitForPos, $mWaitTimeout;
        /* private */ var $mLaggedSlaveMode, $mLastError = 'Unknown error';
 
-       function LoadBalancer()
-       {
-               $this->mServers = array();
-               $this->mConnections = array();
-               $this->mFailFunction = false;
-               $this->mReadIndex = -1;
-               $this->mForce = -1;
-               $this->mLastIndex = -1;
-               $this->mErrorConnection = false;
-       }
-
-       function newFromParams( $servers, $failFunction = false, $waitTimeout = 10 )
-       {
-               $lb = new LoadBalancer;
-               $lb->initialise( $servers, $failFunction, $waitTimeout );
-               return $lb;
-       }
-
-       function initialise( $servers, $failFunction = false, $waitTimeout = 10 )
+       function LoadBalancer( $servers, $failFunction = false, $waitTimeout = 10, $waitForMasterNow = false )
        {
                $this->mServers = $servers;
                $this->mFailFunction = $failFunction;
@@ -70,6 +42,8 @@ class LoadBalancer {
                $this->mWaitForPos = false;
                $this->mWaitTimeout = $waitTimeout;
                $this->mLaggedSlaveMode = false;
+               $this->mErrorConnection = false;
+               $this->mAllowLag = false;
 
                foreach( $servers as $i => $server ) {
                        $this->mLoads[$i] = $server['load'];
@@ -82,6 +56,14 @@ class LoadBalancer {
                                }
                        }
                }
+               if ( $waitForMasterNow ) {
+                       $this->loadMasterPos();
+               }
+       }
+
+       static function newFromParams( $servers, $failFunction = false, $waitTimeout = 10 )
+       {
+               return new LoadBalancer( $servers, $failFunction, $waitTimeout );
        }
 
        /**
@@ -94,17 +76,13 @@ class LoadBalancer {
                        return false;
                }
 
-               $sum = 0;
-               foreach ( $weights as $w ) {
-                       $sum += $w;
-               }
-
+               $sum = array_sum( $weights );
                if ( $sum == 0 ) {
                        # No loads on any of them
-                       # Just pick one at random
-                       foreach ( $weights as $i => $w ) {
-                               $weights[$i] = 1;
-                       }
+                       # In previous versions, this triggered an unweighted random selection,
+                       # but this feature has been removed as of April 2006 to allow for strict 
+                       # separation of query groups. 
+                       return false;
                }
                $max = mt_getrandmax();
                $rand = mt_rand(0, $max) / $max * $sum;
@@ -128,7 +106,6 @@ class LoadBalancer {
                        }
                }
 
-
                # Find out if all the slaves with non-zero load are lagged
                $sum = 0;
                foreach ( $loads as $load ) {
@@ -139,7 +116,7 @@ class LoadBalancer {
                        # Do NOT use the master
                        # Instead, this function will return false, triggering read-only mode,
                        # and a lagged slave will be used instead.
-                       unset ( $loads[0] );
+                       return false;
                }
 
                if ( count( $loads ) == 0 ) {
@@ -178,7 +155,7 @@ class LoadBalancer {
                                $done = false;
                                $totalElapsed = 0;
                                do {
-                                       if ( $wgReadOnly ) {
+                                       if ( $wgReadOnly or $this->mAllowLagged ) {
                                                $i = $this->pickRandom( $loads );
                                        } else {
                                                $i = $this->getRandomNonLagged( $loads );
@@ -190,11 +167,11 @@ class LoadBalancer {
                                        }
                                        $serverIndex = $i;
                                        if ( $i !== false ) {
-                                               wfDebugLog( 'connect', "Using reader #$i: {$this->mServers[$i]['host']}...\n" );
+                                               wfDebugLog( 'connect', "$fname: Using reader #$i: {$this->mServers[$i]['host']}...\n" );
                                                $this->openConnection( $i );
 
                                                if ( !$this->isOpen( $i ) ) {
-                                                       wfDebug( "Failed\n" );
+                                                       wfDebug( "$fname: Failed\n" );
                                                        unset( $loads[$i] );
                                                        $sleepTime = 0;
                                                } else {
@@ -202,7 +179,9 @@ class LoadBalancer {
                                                        if ( isset( $this->mServers[$i]['max threads'] ) &&
                                                          $status['Threads_running'] > $this->mServers[$i]['max threads'] )
                                                        {
-                                                               # Slave is lagged, wait for a while
+                                                               # Too much load, back off and wait for a while.
+                                                               # The sleep time is scaled by the number of threads connected,
+                                                               # to produce a roughly constant global poll rate.
                                                                $sleepTime = AVG_STATUS_POLL * $status['Threads_connected'];
 
                                                                # If we reach the timeout and exit the loop, don't use it
@@ -336,21 +315,33 @@ class LoadBalancer {
         */
        function &getConnection( $i, $fail = true, $groups = array() )
        {
+               global $wgDBtype;
                $fname = 'LoadBalancer::getConnection';
                wfProfileIn( $fname );
 
+
                # Query groups
-               $groupIndex = false;
-               foreach ( $groups as $group ) {
-                       $groupIndex = $this->getGroupIndex( $group );
+               if ( !is_array( $groups ) ) {
+                       $groupIndex = $this->getGroupIndex( $groups, $i );
                        if ( $groupIndex !== false ) {
                                $i = $groupIndex;
-                               break;
+                       }
+               } else {
+                       foreach ( $groups as $group ) {
+                               $groupIndex = $this->getGroupIndex( $group, $i );
+                               if ( $groupIndex !== false ) {
+                                       $i = $groupIndex;
+                                       break;
+                               }
                        }
                }
 
+               # For now, only go through all this for mysql databases
+               if ($wgDBtype != 'mysql') {
+                       $i = $this->getWriterIndex();
+               }
                # Operation-based index
-               if ( $i == DB_SLAVE ) {
+               elseif ( $i == DB_SLAVE ) {
                        $i = $this->getReaderIndex();
                } elseif ( $i == DB_MASTER ) {
                        $i = $this->getWriterIndex();
@@ -426,7 +417,7 @@ class LoadBalancer {
         */
        function reallyOpenConnection( &$server ) {
                if( !is_array( $server ) ) {
-                       wfDebugDieBacktrace( 'You must update your load-balancing configuration. See DefaultSettings.php entry for $wgDBservers.' );
+                       throw new MWException( 'You must update your load-balancing configuration. See DefaultSettings.php entry for $wgDBservers.' );
                }
 
                extract( $server );
@@ -459,7 +450,7 @@ class LoadBalancer {
                                        $conn->reportConnectionError( $this->mLastError );
                                } else {
                                        // If all servers were busy, mLastError will contain something sensible
-                                       wfEmergencyAbort( $conn, $this->mLastError );
+                                       throw new DBConnectionError( $conn, $this->mLastError );
                                }
                        } else {
                                if ( $this->mFailFunction ) {
@@ -467,28 +458,42 @@ class LoadBalancer {
                                } else {
                                        $conn->failFunction( false );
                                }
-                               $conn->reportConnectionError( "{$this->mLastError} ({$conn->mServer})" );
+                               $server = $conn->getProperty( 'mServer' );
+                               $conn->reportConnectionError( "{$this->mLastError} ({$server})" );
                        }
                        $reporting = false;
                }
                wfProfileOut( $fname );
        }
 
-       function getWriterIndex()
-       {
+       function getWriterIndex() {
                return 0;
        }
 
-       function force( $i )
-       {
+       /**
+        * Force subsequent calls to getConnection(DB_SLAVE) to return the 
+        * given index. Set to -1 to restore the original load balancing
+        * behaviour. I thought this was a good idea when I originally 
+        * wrote this class, but it has never been used.
+        */
+       function force( $i ) {
                $this->mForce = $i;
        }
 
-       function haveIndex( $i )
-       {
+       /**
+        * Returns true if the specified index is a valid server index
+        */
+       function haveIndex( $i ) {
                return array_key_exists( $i, $this->mServers );
        }
 
+       /**
+        * Returns true if the specified index is valid and has non-zero load
+        */
+       function isNonZeroLoad( $i ) {
+               return array_key_exists( $i, $this->mServers ) && $this->mLoads[$i] != 0;
+       }
+
        /**
         * Get the number of defined servers (not the number of open connections)
         */
@@ -558,6 +563,13 @@ class LoadBalancer {
                return $this->mLaggedSlaveMode;
        }
 
+       /* Disables/enables lag checks */
+       function allowLagged($mode=null) {
+               if ($mode===null)
+                       return $this->mAllowLagged;
+               $this->mAllowLagged=$mode;
+       }
+
        function pingAll() {
                $success = true;
                foreach ( $this->mConnections as $i => $conn ) {
@@ -596,6 +608,7 @@ class LoadBalancer {
        function getLagTimes() {
                global $wgDBname;
 
+               wfProfileIn( __METHOD__ );
                $expiry = 5;
                $requestRate = 10;
 
@@ -607,6 +620,7 @@ class LoadBalancer {
                        $chance = max( 0, ( $expiry - $elapsed ) * $requestRate );
                        if ( mt_rand( 0, $chance ) != 0 ) {
                                unset( $times['timestamp'] );
+                               wfProfileOut( __METHOD__ );
                                return $times;
                        }
                }
@@ -628,6 +642,8 @@ class LoadBalancer {
 
                # But don't give the timestamp to the caller
                unset($times['timestamp']);
+               wfIncrStats( 'lag_cache_miss' );
+               wfProfileOut( __METHOD__ );
                return $times;
        }
 }