MemcachedPeclBagOStuff::__construct() - Code Metrics - Inspection of "Daily Inspection: Merge "mw.api.messages: Allow pa..." - wikimedia/mediawiki - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Branch — master (a9d73a)

unknown

created 2016-08-30 17:34 UTC

MemcachedPeclBagOStuff::__construct() C

↳ Parent: MemcachedPeclBagOStuff

Complexity

Conditions	10
Paths	97

Size

Total Lines	73
Code Lines	40

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	10
eloc	40
c	1
b	0
f	0
nc	97
nop	1
dl	0
loc	73
rs	5.8564

How to fix Long Method Complexity

<?php
/**
 * Object caching using memcached.
 *
 * 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 Cache
 */

/**
 * A wrapper class for the PECL memcached client
 *
 * @ingroup Cache
 */
class MemcachedPeclBagOStuff extends MemcachedBagOStuff {

	/**
	 * Constructor
	 *
	 * Available parameters are:
	 *   - servers:             The list of IP:port combinations holding the memcached servers.
	 *   - persistent:          Whether to use a persistent connection
	 *   - compress_threshold:  The minimum size an object must be before it is compressed
	 *   - timeout:             The read timeout in microseconds
	 *   - connect_timeout:     The connect timeout in seconds
	 *   - retry_timeout:       Time in seconds to wait before retrying a failed connect attempt
	 *   - server_failure_limit:  Limit for server connect failures before it is removed
	 *   - serializer:          May be either "php" or "igbinary". Igbinary produces more compact
	 *                          values, but serialization is much slower unless the php.ini option
	 *                          igbinary.compact_strings is off.
	 *   - use_binary_protocol  Whether to enable the binary protocol (default is ASCII) (boolean)
	 * @param array $params
	 * @throws InvalidArgumentException
	 */
	function __construct( $params ) {
		parent::__construct( $params );
		$params = $this->applyDefaultParams( $params );

		if ( $params['persistent'] ) {
			// The pool ID must be unique to the server/option combination.
			// The Memcached object is essentially shared for each pool ID.
			// We can only reuse a pool ID if we keep the config consistent.
			$this->client = new Memcached( md5( serialize( $params ) ) );
			if ( count( $this->client->getServerList() ) ) {
				$this->logger->debug( __METHOD__ . ": persistent Memcached object already loaded." );
				return; // already initialized; don't add duplicate servers
			}
		} else {
			$this->client = new Memcached;
		}

		if ( $params['use_binary_protocol'] ) {
			$this->client->setOption( Memcached::OPT_BINARY_PROTOCOL, true );
		}

		if ( isset( $params['retry_timeout'] ) ) {
			$this->client->setOption( Memcached::OPT_RETRY_TIMEOUT, $params['retry_timeout'] );
		}

		if ( isset( $params['server_failure_limit'] ) ) {
			$this->client->setOption( Memcached::OPT_SERVER_FAILURE_LIMIT, $params['server_failure_limit'] );
		}

		// The compression threshold is an undocumented php.ini option for some
		// reason. There's probably not much harm in setting it globally, for
		// compatibility with the settings for the PHP client.
		ini_set( 'memcached.compression_threshold', $params['compress_threshold'] );

		// Set timeouts
		$this->client->setOption( Memcached::OPT_CONNECT_TIMEOUT, $params['connect_timeout'] * 1000 );
		$this->client->setOption( Memcached::OPT_SEND_TIMEOUT, $params['timeout'] );
		$this->client->setOption( Memcached::OPT_RECV_TIMEOUT, $params['timeout'] );
		$this->client->setOption( Memcached::OPT_POLL_TIMEOUT, $params['timeout'] / 1000 );

		// Set libketama mode since it's recommended by the documentation and
		// is as good as any. There's no way to configure libmemcached to use
		// hashes identical to the ones currently in use by the PHP client, and
		// even implementing one of the libmemcached hashes in pure PHP for
		// forwards compatibility would require MemcachedClient::get_sock() to be
		// rewritten.
		$this->client->setOption( Memcached::OPT_LIBKETAMA_COMPATIBLE, true );

		// Set the serializer
		switch ( $params['serializer'] ) {
			case 'php':
				$this->client->setOption( Memcached::OPT_SERIALIZER, Memcached::SERIALIZER_PHP );
				break;
			case 'igbinary':
				if ( !Memcached::HAVE_IGBINARY ) {
					throw new InvalidArgumentException(
						__CLASS__ . ': the igbinary extension is not available ' .
						'but igbinary serialization was requested.'
					);
				}
				$this->client->setOption( Memcached::OPT_SERIALIZER, Memcached::SERIALIZER_IGBINARY );
				break;
			default:
				throw new InvalidArgumentException(
					__CLASS__ . ': invalid value for serializer parameter'
				);
		}
		$servers = [];
		foreach ( $params['servers'] as $host ) {
			$servers[] = IP::splitHostAndPort( $host ); // (ip, port)
		}
		$this->client->addServers( $servers );
	}

	protected function applyDefaultParams( $params ) {
		$params = parent::applyDefaultParams( $params );

		if ( !isset( $params['use_binary_protocol'] ) ) {
			$params['use_binary_protocol'] = false;
		}

		if ( !isset( $params['serializer'] ) ) {
			$params['serializer'] = 'php';
		}

		return $params;
	}

	protected function getWithToken( $key, &$casToken, $flags = 0 ) {
		$this->debugLog( "get($key)" );
		$result = $this->client->get( $this->validateKeyEncoding( $key ), null, $casToken );
		$result = $this->checkResult( $key, $result );
		return $result;
	}

	public function set( $key, $value, $exptime = 0, $flags = 0 ) {
		$this->debugLog( "set($key)" );
		return $this->checkResult( $key, parent::set( $key, $value, $exptime ) );
	}

	protected function cas( $casToken, $key, $value, $exptime = 0 ) {
		$this->debugLog( "cas($key)" );
		return $this->checkResult( $key, parent::cas( $casToken, $key, $value, $exptime ) );
	}

	public function delete( $key ) {
		$this->debugLog( "delete($key)" );
		$result = parent::delete( $key );
		if ( $result === false && $this->client->getResultCode() === Memcached::RES_NOTFOUND ) {
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
			// "Not found" is counted as success in our interface
			return true;
		} else {
			return $this->checkResult( $key, $result );
		}
	}

	public function add( $key, $value, $exptime = 0 ) {
		$this->debugLog( "add($key)" );
		return $this->checkResult( $key, parent::add( $key, $value, $exptime ) );
	}

	public function incr( $key, $value = 1 ) {
		$this->debugLog( "incr($key)" );
		$result = $this->client->increment( $key, $value );
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
		return $this->checkResult( $key, $result );
	}

	public function decr( $key, $value = 1 ) {
		$this->debugLog( "decr($key)" );
		$result = $this->client->decrement( $key, $value );
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
		return $this->checkResult( $key, $result );
	}

	/**
	 * Check the return value from a client method call and take any necessary
	 * action. Returns the value that the wrapper function should return. At
	 * present, the return value is always the same as the return value from
	 * the client, but some day we might find a case where it should be
	 * different.
	 *
	 * @param string $key The key used by the caller, or false if there wasn't one.
	 * @param mixed $result The return value
	 * @return mixed
	 */
	protected function checkResult( $key, $result ) {
		if ( $result !== false ) {
			return $result;
		}
		switch ( $this->client->getResultCode() ) {
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
			case Memcached::RES_SUCCESS:
				break;
			case Memcached::RES_DATA_EXISTS:
			case Memcached::RES_NOTSTORED:
			case Memcached::RES_NOTFOUND:
				$this->debugLog( "result: " . $this->client->getResultMessage() );
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
				break;
			default:
				$msg = $this->client->getResultMessage();
				$logCtx = [];
				if ( $key !== false ) {
					$server = $this->client->getServerByKey( $key );
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
					$logCtx['memcached-server'] = "{$server['host']}:{$server['port']}";
					$logCtx['memcached-key'] = $key;
					$msg = "Memcached error for key \"{memcached-key}\" on server \"{memcached-server}\": $msg";
				} else {
					$msg = "Memcached error: $msg";
				}
				$this->logger->error( $msg, $logCtx );
				$this->setLastError( BagOStuff::ERR_UNEXPECTED );
		}
		return $result;
	}

	public function getMulti( array $keys, $flags = 0 ) {
		$this->debugLog( 'getMulti(' . implode( ', ', $keys ) . ')' );
		foreach ( $keys as $key ) {
			$this->validateKeyEncoding( $key );
		}
		$result = $this->client->getMulti( $keys ) ?: [];
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
		return $this->checkResult( false, $result );
	}

	/**
	 * @param array $data
	 * @param int $exptime
	 * @return bool
	 */
	public function setMulti( array $data, $exptime = 0 ) {
		$this->debugLog( 'setMulti(' . implode( ', ', array_keys( $data ) ) . ')' );
		foreach ( array_keys( $data ) as $key ) {
			$this->validateKeyEncoding( $key );
		}
		$result = $this->client->setMulti( $data, $this->fixExpiry( $exptime ) );
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
		return $this->checkResult( false, $result );
	}

	public function changeTTL( $key, $expiry = 0 ) {
		$this->debugLog( "touch($key)" );
		$result = $this->client->touch( $key, $expiry );
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
		return $this->checkResult( $key, $result );
	}
}


Branch — master (a9d73a)

MemcachedPeclBagOStuff::__construct() C

Complexity

Size

Duplication

Importance

How to fix Long Method Complexity

Long Method

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

1			<?php
2			/**
3			* Object caching using memcached.
4			*
5			* This program is free software; you can redistribute it and/or modify
6			* it under the terms of the GNU General Public License as published by
7			* the Free Software Foundation; either version 2 of the License, or
8			* (at your option) any later version.
9			*
10			* This program is distributed in the hope that it will be useful,
11			* but WITHOUT ANY WARRANTY; without even the implied warranty of
12			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13			* GNU General Public License for more details.
14			*
15			* You should have received a copy of the GNU General Public License along
16			* with this program; if not, write to the Free Software Foundation, Inc.,
17			* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
18			* http://www.gnu.org/copyleft/gpl.html
19			*
20			* @file
21			* @ingroup Cache
22			*/
23
24			/**
25			* A wrapper class for the PECL memcached client
26			*
27			* @ingroup Cache
28			*/
29			class MemcachedPeclBagOStuff extends MemcachedBagOStuff {
30
31			/**
32			* Constructor
33			*
34			* Available parameters are:
35			* - servers: The list of IP:port combinations holding the memcached servers.
36			* - persistent: Whether to use a persistent connection
37			* - compress_threshold: The minimum size an object must be before it is compressed
38			* - timeout: The read timeout in microseconds
39			* - connect_timeout: The connect timeout in seconds
40			* - retry_timeout: Time in seconds to wait before retrying a failed connect attempt
41			* - server_failure_limit: Limit for server connect failures before it is removed
42			* - serializer: May be either "php" or "igbinary". Igbinary produces more compact
43			* values, but serialization is much slower unless the php.ini option
44			* igbinary.compact_strings is off.
45			* - use_binary_protocol Whether to enable the binary protocol (default is ASCII) (boolean)
46			* @param array $params
47			* @throws InvalidArgumentException
48			*/
49			function __construct( $params ) {
50			parent::__construct( $params );
51			$params = $this->applyDefaultParams( $params );
52
53			if ( $params['persistent'] ) {
54			// The pool ID must be unique to the server/option combination.
55			// The Memcached object is essentially shared for each pool ID.
56			// We can only reuse a pool ID if we keep the config consistent.
57			$this->client = new Memcached( md5( serialize( $params ) ) );
58			if ( count( $this->client->getServerList() ) ) {
59			$this->logger->debug( __METHOD__ . ": persistent Memcached object already loaded." );
60			return; // already initialized; don't add duplicate servers
61			}
62			} else {
63			$this->client = new Memcached;
64			}
65
66			if ( $params['use_binary_protocol'] ) {
67			$this->client->setOption( Memcached::OPT_BINARY_PROTOCOL, true );
68			}
69
70			if ( isset( $params['retry_timeout'] ) ) {
71			$this->client->setOption( Memcached::OPT_RETRY_TIMEOUT, $params['retry_timeout'] );
72			}
73
74			if ( isset( $params['server_failure_limit'] ) ) {
75			$this->client->setOption( Memcached::OPT_SERVER_FAILURE_LIMIT, $params['server_failure_limit'] );
76			}
77
78			// The compression threshold is an undocumented php.ini option for some
79			// reason. There's probably not much harm in setting it globally, for
80			// compatibility with the settings for the PHP client.
81			ini_set( 'memcached.compression_threshold', $params['compress_threshold'] );
82
83			// Set timeouts
84			$this->client->setOption( Memcached::OPT_CONNECT_TIMEOUT, $params['connect_timeout'] * 1000 );
85			$this->client->setOption( Memcached::OPT_SEND_TIMEOUT, $params['timeout'] );
86			$this->client->setOption( Memcached::OPT_RECV_TIMEOUT, $params['timeout'] );
87			$this->client->setOption( Memcached::OPT_POLL_TIMEOUT, $params['timeout'] / 1000 );
88
89			// Set libketama mode since it's recommended by the documentation and
90			// is as good as any. There's no way to configure libmemcached to use
91			// hashes identical to the ones currently in use by the PHP client, and
92			// even implementing one of the libmemcached hashes in pure PHP for
93			// forwards compatibility would require MemcachedClient::get_sock() to be
94			// rewritten.
95			$this->client->setOption( Memcached::OPT_LIBKETAMA_COMPATIBLE, true );
96
97			// Set the serializer
98			switch ( $params['serializer'] ) {
99			case 'php':
100			$this->client->setOption( Memcached::OPT_SERIALIZER, Memcached::SERIALIZER_PHP );
101			break;
102			case 'igbinary':
103			if ( !Memcached::HAVE_IGBINARY ) {
104			throw new InvalidArgumentException(
105			__CLASS__ . ': the igbinary extension is not available ' .
106			'but igbinary serialization was requested.'
107			);
108			}
109			$this->client->setOption( Memcached::OPT_SERIALIZER, Memcached::SERIALIZER_IGBINARY );
110			break;
111			default:
112			throw new InvalidArgumentException(
113			__CLASS__ . ': invalid value for serializer parameter'
114			);
115			}
116			$servers = [];
117			foreach ( $params['servers'] as $host ) {
118			$servers[] = IP::splitHostAndPort( $host ); // (ip, port)
119			}
120			$this->client->addServers( $servers );
121			}
122
123			protected function applyDefaultParams( $params ) {
124			$params = parent::applyDefaultParams( $params );
125
126			if ( !isset( $params['use_binary_protocol'] ) ) {
127			$params['use_binary_protocol'] = false;
128			}
129
130			if ( !isset( $params['serializer'] ) ) {
131			$params['serializer'] = 'php';
132			}
133
134			return $params;
135			}
136
137			protected function getWithToken( $key, &$casToken, $flags = 0 ) {
138			$this->debugLog( "get($key)" );
139			$result = $this->client->get( $this->validateKeyEncoding( $key ), null, $casToken );
140			$result = $this->checkResult( $key, $result );
141			return $result;
142			}
143
144			public function set( $key, $value, $exptime = 0, $flags = 0 ) {
145			$this->debugLog( "set($key)" );
146			return $this->checkResult( $key, parent::set( $key, $value, $exptime ) );
147			}
148
149			protected function cas( $casToken, $key, $value, $exptime = 0 ) {
150			$this->debugLog( "cas($key)" );
151			return $this->checkResult( $key, parent::cas( $casToken, $key, $value, $exptime ) );
152			}
153
154			public function delete( $key ) {
155			$this->debugLog( "delete($key)" );
156			$result = parent::delete( $key );
157			if ( $result === false && $this->client->getResultCode() === Memcached::RES_NOTFOUND ) {
			0 ignored issues – show Bug introduced 2016-02-23 18:13 UTC by Report Bug Copy Issue Report The method `getResultCode` does only exist in `Memcached`, but not in `MemcachedClient`. It seems like the method you are trying to call exists only in some of the possible types. Let’s take a look at an example: class A { public function foo() { } } class B extends A { public function bar() { } } /** * @param A\|B $x / function someFunction($x) { $x->foo(); // This call is fine as the method exists in A and B. $x->bar(); // This method only exists in B and might cause an error. } Available Fixes Add an additional type-check: /* * @param A\|B $x / function someFunction($x) { $x->foo(); if ($x instanceof B) { $x->bar(); } } Only allow a single type to be passed if the variable comes from a parameter: function someFunction(B $x) { /* ... */ } Loading history...
158			// "Not found" is counted as success in our interface
159			return true;
160			} else {
161			return $this->checkResult( $key, $result );
162			}
163			}
164
165			public function add( $key, $value, $exptime = 0 ) {
166			$this->debugLog( "add($key)" );
167			return $this->checkResult( $key, parent::add( $key, $value, $exptime ) );
168			}
169
170			public function incr( $key, $value = 1 ) {
171			$this->debugLog( "incr($key)" );
172			$result = $this->client->increment( $key, $value );
			0 ignored issues – show Bug introduced 2016-02-23 18:13 UTC by Report Bug Copy Issue Report The method `increment` does only exist in `Memcached`, but not in `MemcachedClient`. It seems like the method you are trying to call exists only in some of the possible types. Let’s take a look at an example: class A { public function foo() { } } class B extends A { public function bar() { } } /** * @param A\|B $x / function someFunction($x) { $x->foo(); // This call is fine as the method exists in A and B. $x->bar(); // This method only exists in B and might cause an error. } Available Fixes Add an additional type-check: /* * @param A\|B $x / function someFunction($x) { $x->foo(); if ($x instanceof B) { $x->bar(); } } Only allow a single type to be passed if the variable comes from a parameter: function someFunction(B $x) { /* ... */ } Loading history...
173			return $this->checkResult( $key, $result );
174			}
175
176			public function decr( $key, $value = 1 ) {
177			$this->debugLog( "decr($key)" );
178			$result = $this->client->decrement( $key, $value );
			0 ignored issues – show Bug introduced 2016-02-23 18:13 UTC by Report Bug Copy Issue Report The method `decrement` does only exist in `Memcached`, but not in `MemcachedClient`. It seems like the method you are trying to call exists only in some of the possible types. Let’s take a look at an example: class A { public function foo() { } } class B extends A { public function bar() { } } /** * @param A\|B $x / function someFunction($x) { $x->foo(); // This call is fine as the method exists in A and B. $x->bar(); // This method only exists in B and might cause an error. } Available Fixes Add an additional type-check: /* * @param A\|B $x / function someFunction($x) { $x->foo(); if ($x instanceof B) { $x->bar(); } } Only allow a single type to be passed if the variable comes from a parameter: function someFunction(B $x) { /* ... */ } Loading history...
179			return $this->checkResult( $key, $result );
180			}
181
182			/**
183			* Check the return value from a client method call and take any necessary
184			* action. Returns the value that the wrapper function should return. At
185			* present, the return value is always the same as the return value from
186			* the client, but some day we might find a case where it should be
187			* different.
188			*
189			* @param string $key The key used by the caller, or false if there wasn't one.
190			* @param mixed $result The return value
191			* @return mixed
192			*/
193			protected function checkResult( $key, $result ) {
194			if ( $result !== false ) {
195			return $result;
196			}
197			switch ( $this->client->getResultCode() ) {
			0 ignored issues – show Bug introduced 2016-02-23 18:13 UTC by Report Bug Copy Issue Report The method `getResultCode` does only exist in `Memcached`, but not in `MemcachedClient`. It seems like the method you are trying to call exists only in some of the possible types. Let’s take a look at an example: class A { public function foo() { } } class B extends A { public function bar() { } } /** * @param A\|B $x / function someFunction($x) { $x->foo(); // This call is fine as the method exists in A and B. $x->bar(); // This method only exists in B and might cause an error. } Available Fixes Add an additional type-check: /* * @param A\|B $x / function someFunction($x) { $x->foo(); if ($x instanceof B) { $x->bar(); } } Only allow a single type to be passed if the variable comes from a parameter: function someFunction(B $x) { /* ... */ } Loading history...
198			case Memcached::RES_SUCCESS:
199			break;
200			case Memcached::RES_DATA_EXISTS:
201			case Memcached::RES_NOTSTORED:
202			case Memcached::RES_NOTFOUND:
203			$this->debugLog( "result: " . $this->client->getResultMessage() );
			0 ignored issues – show Bug introduced 2016-02-23 18:13 UTC by Report Bug Copy Issue Report The method `getResultMessage` does only exist in `Memcached`, but not in `MemcachedClient`. It seems like the method you are trying to call exists only in some of the possible types. Let’s take a look at an example: class A { public function foo() { } } class B extends A { public function bar() { } } /** * @param A\|B $x / function someFunction($x) { $x->foo(); // This call is fine as the method exists in A and B. $x->bar(); // This method only exists in B and might cause an error. } Available Fixes Add an additional type-check: /* * @param A\|B $x / function someFunction($x) { $x->foo(); if ($x instanceof B) { $x->bar(); } } Only allow a single type to be passed if the variable comes from a parameter: function someFunction(B $x) { /* ... */ } Loading history...
204			break;
205			default:
206			$msg = $this->client->getResultMessage();
207			$logCtx = [];
208			if ( $key !== false ) {
209			$server = $this->client->getServerByKey( $key );
			0 ignored issues – show Bug introduced 2016-02-23 18:13 UTC by Report Bug Copy Issue Report The method `getServerByKey` does only exist in `Memcached`, but not in `MemcachedClient`. It seems like the method you are trying to call exists only in some of the possible types. Let’s take a look at an example: class A { public function foo() { } } class B extends A { public function bar() { } } /** * @param A\|B $x / function someFunction($x) { $x->foo(); // This call is fine as the method exists in A and B. $x->bar(); // This method only exists in B and might cause an error. } Available Fixes Add an additional type-check: /* * @param A\|B $x / function someFunction($x) { $x->foo(); if ($x instanceof B) { $x->bar(); } } Only allow a single type to be passed if the variable comes from a parameter: function someFunction(B $x) { /* ... */ } Loading history...
210			$logCtx['memcached-server'] = "{$server['host']}:{$server['port']}";
211			$logCtx['memcached-key'] = $key;
212			$msg = "Memcached error for key \"{memcached-key}\" on server \"{memcached-server}\": $msg";
213			} else {
214			$msg = "Memcached error: $msg";
215			}
216			$this->logger->error( $msg, $logCtx );
217			$this->setLastError( BagOStuff::ERR_UNEXPECTED );
218			}
219			return $result;
220			}
221
222			public function getMulti( array $keys, $flags = 0 ) {
223			$this->debugLog( 'getMulti(' . implode( ', ', $keys ) . ')' );
224			foreach ( $keys as $key ) {
225			$this->validateKeyEncoding( $key );
226			}
227			$result = $this->client->getMulti( $keys ) ?: [];
			0 ignored issues – show Bug introduced 2016-02-23 18:13 UTC by Report Bug Copy Issue Report The method `getMulti` does only exist in `Memcached`, but not in `MemcachedClient`. It seems like the method you are trying to call exists only in some of the possible types. Let’s take a look at an example: class A { public function foo() { } } class B extends A { public function bar() { } } /** * @param A\|B $x / function someFunction($x) { $x->foo(); // This call is fine as the method exists in A and B. $x->bar(); // This method only exists in B and might cause an error. } Available Fixes Add an additional type-check: /* * @param A\|B $x / function someFunction($x) { $x->foo(); if ($x instanceof B) { $x->bar(); } } Only allow a single type to be passed if the variable comes from a parameter: function someFunction(B $x) { /* ... */ } Loading history...
228			return $this->checkResult( false, $result );
229			}
230
231			/**
232			* @param array $data
233			* @param int $exptime
234			* @return bool
235			*/
236			public function setMulti( array $data, $exptime = 0 ) {
237			$this->debugLog( 'setMulti(' . implode( ', ', array_keys( $data ) ) . ')' );
238			foreach ( array_keys( $data ) as $key ) {
239			$this->validateKeyEncoding( $key );
240			}
241			$result = $this->client->setMulti( $data, $this->fixExpiry( $exptime ) );
			0 ignored issues – show Bug introduced 2016-02-23 18:13 UTC by Report Bug Copy Issue Report The method `setMulti` does only exist in `Memcached`, but not in `MemcachedClient`. It seems like the method you are trying to call exists only in some of the possible types. Let’s take a look at an example: class A { public function foo() { } } class B extends A { public function bar() { } } /** * @param A\|B $x / function someFunction($x) { $x->foo(); // This call is fine as the method exists in A and B. $x->bar(); // This method only exists in B and might cause an error. } Available Fixes Add an additional type-check: /* * @param A\|B $x / function someFunction($x) { $x->foo(); if ($x instanceof B) { $x->bar(); } } Only allow a single type to be passed if the variable comes from a parameter: function someFunction(B $x) { /* ... */ } Loading history...
242			return $this->checkResult( false, $result );
243			}
244
245			public function changeTTL( $key, $expiry = 0 ) {
246			$this->debugLog( "touch($key)" );
247			$result = $this->client->touch( $key, $expiry );
			0 ignored issues – show Bug introduced 2016-08-12 17:52 UTC by Report Bug Copy Issue Report The method `touch` does only exist in `MemcachedClient`, but not in `Memcached`. It seems like the method you are trying to call exists only in some of the possible types. Let’s take a look at an example: class A { public function foo() { } } class B extends A { public function bar() { } } /** * @param A\|B $x / function someFunction($x) { $x->foo(); // This call is fine as the method exists in A and B. $x->bar(); // This method only exists in B and might cause an error. } Available Fixes Add an additional type-check: /* * @param A\|B $x / function someFunction($x) { $x->foo(); if ($x instanceof B) { $x->bar(); } } Only allow a single type to be passed if the variable comes from a parameter: function someFunction(B $x) { /* ... */ } Loading history...
248			return $this->checkResult( $key, $result );
249			}
250			}
251

wikimedia / mediawiki

Branch — master (a9d73a)

MemcachedPeclBagOStuff::__construct() C

Complexity

Size

Duplication

Importance

How to fix Long Method Complexity

Long Method

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Duplication Side-by-Side

Filter issues like