LoadMonitor::clearCaches() - Code Metrics - Inspection of "Daily Inspection: Add @deprecated to Article::prep..." - wikimedia/mediawiki - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Branch — master (e9bc15)

unknown

created 2016-10-06 17:05 UTC

LoadMonitor::clearCaches() A

↳ Parent: LoadMonitor

Complexity

Conditions	1
Paths	1

Size

Total Lines	5
Code Lines	4

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
eloc	4
nc	1
nop	0
dl	0
loc	5
rs	9.4285
c	0
b	0
f	0

<?php
/**
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 * http://www.gnu.org/copyleft/gpl.html
 *
 * @file
 * @ingroup Database
 */

use Psr\Log\LoggerInterface;

/**
 * Basic DB load monitor with no external dependencies
 * Uses memcached to cache the replication lag for a short time
 *
 * @ingroup Database
 */
class LoadMonitor implements ILoadMonitor {
	/** @var ILoadBalancer */
	protected $parent;
	/** @var BagOStuff */
	protected $srvCache;
	/** @var BagOStuff */
	protected $mainCache;
	/** @var LoggerInterface */
	protected $replLogger;

	/** @var float Moving average ratio (e.g. 0.1 for 10% weight to new weight) */
	private $movingAveRatio;

	const VERSION = 1; // cache key version

	public function __construct(
		ILoadBalancer $lb, BagOStuff $srvCache, BagOStuff $cache, array $options = []
	) {
		$this->parent = $lb;
		$this->srvCache = $srvCache;
		$this->mainCache = $cache;
		$this->replLogger = new \Psr\Log\NullLogger();

		$this->movingAveRatio = isset( $options['movingAveRatio'] )
			? $options['movingAveRatio']
			: 0.1;
	}

	public function setLogger( LoggerInterface $logger ) {
		$this->replLogger = $logger;
	}

	public function scaleLoads( array &$weightByServer, $domain ) {
		$serverIndexes = array_keys( $weightByServer );
		$states = $this->getServerStates( $serverIndexes, $domain );
		$coefficientsByServer = $states['weightScales'];
		foreach ( $weightByServer as $i => $weight ) {
			if ( isset( $coefficientsByServer[$i] ) ) {
				$weightByServer[$i] = $weight * $coefficientsByServer[$i];
			} else { // server recently added to config?
				$host = $this->parent->getServerName( $i );
				$this->replLogger->error( __METHOD__ . ": host $host not in cache" );
			}
		}
	}

	public function getLagTimes( array $serverIndexes, $domain ) {
		$states = $this->getServerStates( $serverIndexes, $domain );

		return $states['lagTimes'];
	}

	protected function getServerStates( array $serverIndexes, $domain ) {
		$writerIndex = $this->parent->getWriterIndex();
		if ( count( $serverIndexes ) == 1 && reset( $serverIndexes ) == $writerIndex ) {
			# Single server only, just return zero without caching
			return [
				'lagTimes' => [ $writerIndex => 0 ],
				'weightScales' => [ $writerIndex => 1.0 ]
			];
		}

		$key = $this->getCacheKey( $serverIndexes );
		# Randomize TTLs to reduce stampedes (4.0 - 5.0 sec)
		$ttl = mt_rand( 4e6, 5e6 ) / 1e6;
		# Keep keys around longer as fallbacks
		$staleTTL = 60;

		# (a) Check the local APC cache
		$value = $this->srvCache->get( $key );
		if ( $value && $value['timestamp'] > ( microtime( true ) - $ttl ) ) {
			$this->replLogger->debug( __METHOD__ . ": got lag times ($key) from local cache" );
			return $value; // cache hit
		}
		$staleValue = $value ?: false;

		# (b) Check the shared cache and backfill APC
		$value = $this->mainCache->get( $key );
		if ( $value && $value['timestamp'] > ( microtime( true ) - $ttl ) ) {
			$this->srvCache->set( $key, $value, $staleTTL );
			$this->replLogger->debug( __METHOD__ . ": got lag times ($key) from main cache" );

			return $value; // cache hit
		}
		$staleValue = $value ?: $staleValue;

		# (c) Cache key missing or expired; regenerate and backfill
		if ( $this->mainCache->lock( $key, 0, 10 ) ) {
			# Let this process alone update the cache value
			$cache = $this->mainCache;
			/** @noinspection PhpUnusedLocalVariableInspection */
			$unlocker = new ScopedCallback( function () use ( $cache, $key ) {
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
				$cache->unlock( $key );
			} );
		} elseif ( $staleValue ) {
			# Could not acquire lock but an old cache exists, so use it
			return $staleValue;
		}

		$lagTimes = [];
		$weightScales = [];
		$movAveRatio = $this->movingAveRatio;
		foreach ( $serverIndexes as $i ) {
			if ( $i == $this->parent->getWriterIndex() ) {
				$lagTimes[$i] = 0; // master always has no lag
				$weightScales[$i] = 1.0; // nominal weight
				continue;
			}

			$conn = $this->parent->getAnyOpenConnection( $i );
			if ( $conn ) {
				$close = false; // already open
			} else {
				$conn = $this->parent->openConnection( $i, $domain );
				$close = true; // new connection
			}

			$lastWeight = isset( $staleValue['weightScales'][$i] )
				? $staleValue['weightScales'][$i]
				: 1.0;
			$coefficient = $this->getWeightScale( $i, $conn ?: null );
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
			$newWeight = $movAveRatio * $coefficient + ( 1 - $movAveRatio ) * $lastWeight;

			// Scale from 10% to 100% of nominal weight
			$weightScales[$i] = max( $newWeight, .10 );

			if ( !$conn ) {
				$lagTimes[$i] = false;
				$host = $this->parent->getServerName( $i );
				$this->replLogger->error( __METHOD__ . ": host $host is unreachable" );
				continue;
			}

			$lagTimes[$i] = $conn->getLag();
			if ( $lagTimes[$i] === false ) {
				$host = $this->parent->getServerName( $i );
				$this->replLogger->error( __METHOD__ . ": host $host is not replicating?" );
			}

			if ( $close ) {
				# Close the connection to avoid sleeper connections piling up.
				# Note that the caller will pick one of these DBs and reconnect,
				# which is slightly inefficient, but this only matters for the lag
				# time cache miss cache, which is far less common that cache hits.
				$this->parent->closeConnection( $conn );
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
			}
		}

		# Add a timestamp key so we know when it was cached
		$value = [
			'lagTimes' => $lagTimes,
			'weightScales' => $weightScales,
			'timestamp' => microtime( true )
		];
		$this->mainCache->set( $key, $value, $staleTTL );
		$this->srvCache->set( $key, $value, $staleTTL );
		$this->replLogger->info( __METHOD__ . ": re-calculated lag times ($key)" );

		return $value;
	}

	/**
	 * @param integer $index Server index
	 * @param IDatabase|null $conn Connection handle or null on connection failure
	 * @return float
	 */
	protected function getWeightScale( $index, IDatabase $conn = null ) {
		return $conn ? 1.0 : 0.0;
	}

	private function getCacheKey( array $serverIndexes ) {
		sort( $serverIndexes );
		// Lag is per-server, not per-DB, so key on the master DB name
		return $this->srvCache->makeGlobalKey(
			'lag-times',
			self::VERSION,
			$this->parent->getServerName( $this->parent->getWriterIndex() ),
			implode( '-', $serverIndexes )
		);
	}
}


1		<?php
2		/**
3		* This program is free software; you can redistribute it and/or modify
4		* it under the terms of the GNU General Public License as published by
5		* the Free Software Foundation; either version 2 of the License, or
6		* (at your option) any later version.
7		*
8		* This program is distributed in the hope that it will be useful,
9		* but WITHOUT ANY WARRANTY; without even the implied warranty of
10		* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11		* GNU General Public License for more details.
12		*
13		* You should have received a copy of the GNU General Public License along
14		* with this program; if not, write to the Free Software Foundation, Inc.,
15		* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
16		* http://www.gnu.org/copyleft/gpl.html
17		*
18		* @file
19		* @ingroup Database
20		*/
21
22		use Psr\Log\LoggerInterface;
23
24		/**
25		* Basic DB load monitor with no external dependencies
26		* Uses memcached to cache the replication lag for a short time
27		*
28		* @ingroup Database
29		*/
30		class LoadMonitor implements ILoadMonitor {
31		/** @var ILoadBalancer */
32		protected $parent;
33		/** @var BagOStuff */
34		protected $srvCache;
35		/** @var BagOStuff */
36		protected $mainCache;
37		/** @var LoggerInterface */
38		protected $replLogger;
39
40		/** @var float Moving average ratio (e.g. 0.1 for 10% weight to new weight) */
41		private $movingAveRatio;
42
43		const VERSION = 1; // cache key version
44
45		public function __construct(
46		ILoadBalancer $lb, BagOStuff $srvCache, BagOStuff $cache, array $options = []
47		) {
48		$this->parent = $lb;
49		$this->srvCache = $srvCache;
50		$this->mainCache = $cache;
51		$this->replLogger = new \Psr\Log\NullLogger();
52
53		$this->movingAveRatio = isset( $options['movingAveRatio'] )
54		? $options['movingAveRatio']
55		: 0.1;
56		}
57
58		public function setLogger( LoggerInterface $logger ) {
59		$this->replLogger = $logger;
60		}
61
62		public function scaleLoads( array &$weightByServer, $domain ) {
63		$serverIndexes = array_keys( $weightByServer );
64		$states = $this->getServerStates( $serverIndexes, $domain );
65		$coefficientsByServer = $states['weightScales'];
66		foreach ( $weightByServer as $i => $weight ) {
67		if ( isset( $coefficientsByServer[$i] ) ) {
68		$weightByServer[$i] = $weight * $coefficientsByServer[$i];
69		} else { // server recently added to config?
70		$host = $this->parent->getServerName( $i );
71		$this->replLogger->error( __METHOD__ . ": host $host not in cache" );
72		}
73		}
74		}
75
76		public function getLagTimes( array $serverIndexes, $domain ) {
77		$states = $this->getServerStates( $serverIndexes, $domain );
78
79		return $states['lagTimes'];
80		}
81
82		protected function getServerStates( array $serverIndexes, $domain ) {
83		$writerIndex = $this->parent->getWriterIndex();
84		if ( count( $serverIndexes ) == 1 && reset( $serverIndexes ) == $writerIndex ) {
85		# Single server only, just return zero without caching
86		return [
87		'lagTimes' => [ $writerIndex => 0 ],
88		'weightScales' => [ $writerIndex => 1.0 ]
89		];
90		}
91
92		$key = $this->getCacheKey( $serverIndexes );
93		# Randomize TTLs to reduce stampedes (4.0 - 5.0 sec)
94		$ttl = mt_rand( 4e6, 5e6 ) / 1e6;
95		# Keep keys around longer as fallbacks
96		$staleTTL = 60;
97
98		# (a) Check the local APC cache
99		$value = $this->srvCache->get( $key );
100		if ( $value && $value['timestamp'] > ( microtime( true ) - $ttl ) ) {
101		$this->replLogger->debug( __METHOD__ . ": got lag times ($key) from local cache" );
102		return $value; // cache hit
103		}
104		$staleValue = $value ?: false;
105
106		# (b) Check the shared cache and backfill APC
107		$value = $this->mainCache->get( $key );
108		if ( $value && $value['timestamp'] > ( microtime( true ) - $ttl ) ) {
109		$this->srvCache->set( $key, $value, $staleTTL );
110		$this->replLogger->debug( __METHOD__ . ": got lag times ($key) from main cache" );
111
112		return $value; // cache hit
113		}
114		$staleValue = $value ?: $staleValue;
115
116		# (c) Cache key missing or expired; regenerate and backfill
117		if ( $this->mainCache->lock( $key, 0, 10 ) ) {
118		# Let this process alone update the cache value
119		$cache = $this->mainCache;
120		/** @noinspection PhpUnusedLocalVariableInspection */
121		$unlocker = new ScopedCallback( function () use ( $cache, $key ) {
		0 ignored issues – show Unused Code introduced 2016-09-16 18:25 UTC by Report Bug Copy Issue Report `$unlocker` is not used, you could remove the assignment. This check looks for variable assignements that are either overwritten by other assignments or where the variable is not used subsequently. $myVar = 'Value'; $higher = false; if (rand(1, 6) > 3) { $higher = true; } else { $higher = false; } Both the `$myVar` assignment in line 1 and the `$higher` assignment in line 2 are dead. The first because `$myVar` is never used and the second because `$higher` is always overwritten for every possible time line. Loading history... Deprecated Code introduced 2016-09-29 17:29 UTC by Report Bug Copy Issue Report The class `ScopedCallback` has been deprecated with message: since 1.28 use Wikimedia\ScopedCallback This class, trait or interface has been deprecated. The supplier of the file has supplied an explanatory message. The explanatory message should give you some clue as to whether and when the type will be removed from the class and what other constant to use instead. Loading history...
122		$cache->unlock( $key );
123		} );
124		} elseif ( $staleValue ) {
125		# Could not acquire lock but an old cache exists, so use it
126		return $staleValue;
127		}
128
129		$lagTimes = [];
130		$weightScales = [];
131		$movAveRatio = $this->movingAveRatio;
132		foreach ( $serverIndexes as $i ) {
133		if ( $i == $this->parent->getWriterIndex() ) {
134		$lagTimes[$i] = 0; // master always has no lag
135		$weightScales[$i] = 1.0; // nominal weight
136		continue;
137		}
138
139		$conn = $this->parent->getAnyOpenConnection( $i );
140		if ( $conn ) {
141		$close = false; // already open
142		} else {
143		$conn = $this->parent->openConnection( $i, $domain );
144		$close = true; // new connection
145		}
146
147		$lastWeight = isset( $staleValue['weightScales'][$i] )
148		? $staleValue['weightScales'][$i]
149		: 1.0;
150		$coefficient = $this->getWeightScale( $i, $conn ?: null );
		0 ignored issues – show Bug introduced 2016-10-04 18:06 UTC by Report Bug Copy Issue Report It seems like `$conn ?: null` can also be of type `boolean`; however, `LoadMonitor::getWeightScale()` does only seem to accept `null\|object<IDatabase>`, maybe add an additional type check? If a method or function can return multiple different values and unless you are sure that you only can receive a single value in this context, we recommend to add an additional type check: /** * @return array\|string */ function returnsDifferentValues($x) { if ($x) { return 'foo'; } return array(); } $x = returnsDifferentValues($y); if (is_array($x)) { // $x is an array. } If this a common case that PHP Analyzer should handle natively, please let us know by opening an issue. Loading history...
151		$newWeight = $movAveRatio * $coefficient + ( 1 - $movAveRatio ) * $lastWeight;
152
153		// Scale from 10% to 100% of nominal weight
154		$weightScales[$i] = max( $newWeight, .10 );
155
156	View Code Duplication	if ( !$conn ) {
157		$lagTimes[$i] = false;
158		$host = $this->parent->getServerName( $i );
159		$this->replLogger->error( __METHOD__ . ": host $host is unreachable" );
160		continue;
161		}
162
163		$lagTimes[$i] = $conn->getLag();
164	View Code Duplication	if ( $lagTimes[$i] === false ) {
165		$host = $this->parent->getServerName( $i );
166		$this->replLogger->error( __METHOD__ . ": host $host is not replicating?" );
167		}
168
169		if ( $close ) {
170		# Close the connection to avoid sleeper connections piling up.
171		# Note that the caller will pick one of these DBs and reconnect,
172		# which is slightly inefficient, but this only matters for the lag
173		# time cache miss cache, which is far less common that cache hits.
174		$this->parent->closeConnection( $conn );
		0 ignored issues – show Bug introduced 2016-09-14 18:31 UTC by Report Bug Copy Issue Report It seems like `$conn` can also be of type `boolean`; however, `ILoadBalancer::closeConnection()` does only seem to accept `object<IDatabase>`, maybe add an additional type check? If a method or function can return multiple different values and unless you are sure that you only can receive a single value in this context, we recommend to add an additional type check: /** * @return array\|string */ function returnsDifferentValues($x) { if ($x) { return 'foo'; } return array(); } $x = returnsDifferentValues($y); if (is_array($x)) { // $x is an array. } If this a common case that PHP Analyzer should handle natively, please let us know by opening an issue. Loading history...
175		}
176		}
177
178		# Add a timestamp key so we know when it was cached
179		$value = [
180		'lagTimes' => $lagTimes,
181		'weightScales' => $weightScales,
182		'timestamp' => microtime( true )
183		];
184		$this->mainCache->set( $key, $value, $staleTTL );
185		$this->srvCache->set( $key, $value, $staleTTL );
186		$this->replLogger->info( __METHOD__ . ": re-calculated lag times ($key)" );
187
188		return $value;
189		}
190
191		/**
192		* @param integer $index Server index
193		* @param IDatabase\|null $conn Connection handle or null on connection failure
194		* @return float
195		*/
196		protected function getWeightScale( $index, IDatabase $conn = null ) {
197		return $conn ? 1.0 : 0.0;
198		}
199
200		private function getCacheKey( array $serverIndexes ) {
201		sort( $serverIndexes );
202		// Lag is per-server, not per-DB, so key on the master DB name
203		return $this->srvCache->makeGlobalKey(
204		'lag-times',
205		self::VERSION,
206		$this->parent->getServerName( $this->parent->getWriterIndex() ),
207		implode( '-', $serverIndexes )
208		);
209		}
210		}
211

wikimedia / mediawiki

Branch — master (e9bc15)

LoadMonitor::clearCaches() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like