1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
|
<?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.
* @param array $params
* @throws MWException
*/
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 ( !isset( $params['serializer'] ) ) {
$params['serializer'] = 'php';
}
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 MWMemcached::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 MWException( __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 MWException( __CLASS__ . ': invalid value for serializer parameter' );
}
$servers = array();
foreach ( $params['servers'] as $host ) {
$servers[] = IP::splitHostAndPort( $host ); // (ip, port)
}
$this->client->addServers( $servers );
}
/**
* @param string $key
* @param float $casToken [optional]
* @return mixed
*/
public function get( $key, &$casToken = null ) {
$this->debugLog( "get($key)" );
$result = $this->client->get( $this->encodeKey( $key ), null, $casToken );
$result = $this->checkResult( $key, $result );
return $result;
}
/**
* @param string $key
* @param mixed $value
* @param int $exptime
* @return bool
*/
public function set( $key, $value, $exptime = 0 ) {
$this->debugLog( "set($key)" );
return $this->checkResult( $key, parent::set( $key, $value, $exptime ) );
}
/**
* @param float $casToken
* @param string $key
* @param mixed $value
* @param int $exptime
* @return bool
*/
protected function cas( $casToken, $key, $value, $exptime = 0 ) {
$this->debugLog( "cas($key)" );
return $this->checkResult( $key, parent::cas( $casToken, $key, $value, $exptime ) );
}
/**
* @param string $key
* @return bool
*/
public function delete( $key ) {
$this->debugLog( "delete($key)" );
$result = parent::delete( $key );
if ( $result === false && $this->client->getResultCode() === Memcached::RES_NOTFOUND ) {
// "Not found" is counted as success in our interface
return true;
} else {
return $this->checkResult( $key, $result );
}
}
/**
* @param string $key
* @param int $value
* @param int $exptime
* @return mixed
*/
public function add( $key, $value, $exptime = 0 ) {
$this->debugLog( "add($key)" );
return $this->checkResult( $key, parent::add( $key, $value, $exptime ) );
}
/**
* @param string $key
* @param int $value
* @return mixed
*/
public function incr( $key, $value = 1 ) {
$this->debugLog( "incr($key)" );
$result = $this->client->increment( $key, $value );
return $this->checkResult( $key, $result );
}
/**
* @param string $key
* @param int $value
* @return mixed
*/
public function decr( $key, $value = 1 ) {
$this->debugLog( "decr($key)" );
$result = $this->client->decrement( $key, $value );
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() ) {
case Memcached::RES_SUCCESS:
break;
case Memcached::RES_DATA_EXISTS:
case Memcached::RES_NOTSTORED:
case Memcached::RES_NOTFOUND:
$this->debugLog( "result: " . $this->client->getResultMessage() );
break;
default:
$msg = $this->client->getResultMessage();
$logCtx = array();
if ( $key !== false ) {
$server = $this->client->getServerByKey( $key );
$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;
}
/**
* @param array $keys
* @return array
*/
public function getMulti( array $keys ) {
$this->debugLog( 'getMulti(' . implode( ', ', $keys ) . ')' );
$callback = array( $this, 'encodeKey' );
$result = $this->client->getMulti( array_map( $callback, $keys ) );
$result = $result ?: array(); // must be an array
return $this->checkResult( false, $result );
}
/**
* @param array $data
* @param int $exptime
* @return bool
*/
public function setMulti( array $data, $exptime = 0 ) {
foreach ( $data as $key => $value ) {
$encKey = $this->encodeKey( $key );
if ( $encKey !== $key ) {
$data[$encKey] = $value;
unset( $data[$key] );
}
}
$this->debugLog( 'setMulti(' . implode( ', ', array_keys( $data ) ) . ')' );
$result = $this->client->setMulti( $data, $this->fixExpiry( $exptime ) );
return $this->checkResult( false, $result );
}
}
|
