?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
PHPSessionHandler: Implement SessionHandlerInterface
[mediawiki.git] / includes / libs / objectcache / MemcachedClient.php
blob8007a53842c3e13f57d77ccf6a59649195636e5a
1 <?php
2 // @codingStandardsIgnoreFile It's an external lib and it isn't. Let's not bother.
3 /**
4 * Memcached client for PHP.
5 *
6 * +---------------------------------------------------------------------------+
7 * | memcached client, PHP |
8 * +---------------------------------------------------------------------------+
9 * | Copyright (c) 2003 Ryan T. Dean <rtdean@cytherianage.net> |
10 * | All rights reserved. |
11 * | |
12 * | Redistribution and use in source and binary forms, with or without |
13 * | modification, are permitted provided that the following conditions |
14 * | are met: |
15 * | |
16 * | 1. Redistributions of source code must retain the above copyright |
17 * | notice, this list of conditions and the following disclaimer. |
18 * | 2. Redistributions in binary form must reproduce the above copyright |
19 * | notice, this list of conditions and the following disclaimer in the |
20 * | documentation and/or other materials provided with the distribution. |
21 * | |
22 * | THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
23 * | IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
24 * | OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
25 * | IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
26 * | INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
27 * | NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
28 * | DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
29 * | THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
30 * | (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
31 * | THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
32 * +---------------------------------------------------------------------------+
33 * | Author: Ryan T. Dean <rtdean@cytherianage.net> |
34 * | Heavily influenced by the Perl memcached client by Brad Fitzpatrick. |
35 * | Permission granted by Brad Fitzpatrick for relicense of ported Perl |
36 * | client logic under 2-clause BSD license. |
37 * +---------------------------------------------------------------------------+
38 *
39 * @file
40 * $TCAnet$
41 */
42
43 /**
44 * This is a PHP client for memcached - a distributed memory cache daemon.
45 *
46 * More information is available at http://www.danga.com/memcached/
47 *
48 * Usage example:
49 *
50 * $mc = new MemcachedClient(array(
51 * 'servers' => array(
52 * '127.0.0.1:10000',
53 * array( '192.0.0.1:10010', 2 ),
54 * '127.0.0.1:10020'
55 * ),
56 * 'debug' => false,
57 * 'compress_threshold' => 10240,
58 * 'persistent' => true
59 * ));
60 *
61 * $mc->add( 'key', array( 'some', 'array' ) );
62 * $mc->replace( 'key', 'some random string' );
63 * $val = $mc->get( 'key' );
64 *
65 * @author Ryan T. Dean <rtdean@cytherianage.net>
66 * @version 0.1.2
67 */
68
69 use Psr\Log\LoggerInterface;
70 use Psr\Log\NullLogger;
71
72 // {{{ class MemcachedClient
73 /**
74 * memcached client class implemented using (p)fsockopen()
75 *
76 * @author Ryan T. Dean <rtdean@cytherianage.net>
77 * @ingroup Cache
78 */
79 class MemcachedClient {
80 // {{{ properties
81 // {{{ public
82
83 // {{{ constants
84 // {{{ flags
85
86 /**
87 * Flag: indicates data is serialized
88 */
89 const SERIALIZED = 1;
90
91 /**
92 * Flag: indicates data is compressed
93 */
94 const COMPRESSED = 2;
95
96 /**
97 * Flag: indicates data is an integer
98 */
99 const INTVAL = 4;
100
101 // }}}
102
103 /**
104 * Minimum savings to store data compressed
105 */
106 const COMPRESSION_SAVINGS = 0.20;
107
108 // }}}
109
110 /**
111 * Command statistics
112 *
113 * @var array
114 * @access public
115 */
116 public $stats;
117
118 // }}}
119 // {{{ private
120
121 /**
122 * Cached Sockets that are connected
123 *
124 * @var array
125 * @access private
126 */
127 public $_cache_sock;
128
129 /**
130 * Current debug status; 0 - none to 9 - profiling
131 *
132 * @var bool
133 * @access private
134 */
135 public $_debug;
136
137 /**
138 * Dead hosts, assoc array, 'host'=>'unixtime when ok to check again'
139 *
140 * @var array
141 * @access private
142 */
143 public $_host_dead;
144
145 /**
146 * Is compression available?
147 *
148 * @var bool
149 * @access private
150 */
151 public $_have_zlib;
152
153 /**
154 * Do we want to use compression?
155 *
156 * @var bool
157 * @access private
158 */
159 public $_compress_enable;
160
161 /**
162 * At how many bytes should we compress?
163 *
164 * @var int
165 * @access private
166 */
167 public $_compress_threshold;
168
169 /**
170 * Are we using persistent links?
171 *
172 * @var bool
173 * @access private
174 */
175 public $_persistent;
176
177 /**
178 * If only using one server; contains ip:port to connect to
179 *
180 * @var string
181 * @access private
182 */
183 public $_single_sock;
184
185 /**
186 * Array containing ip:port or array(ip:port, weight)
187 *
188 * @var array
189 * @access private
190 */
191 public $_servers;
192
193 /**
194 * Our bit buckets
195 *
196 * @var array
197 * @access private
198 */
199 public $_buckets;
200
201 /**
202 * Total # of bit buckets we have
203 *
204 * @var int
205 * @access private
206 */
207 public $_bucketcount;
208
209 /**
210 * # of total servers we have
211 *
212 * @var int
213 * @access private
214 */
215 public $_active;
216
217 /**
218 * Stream timeout in seconds. Applies for example to fread()
219 *
220 * @var int
221 * @access private
222 */
223 public $_timeout_seconds;
224
225 /**
226 * Stream timeout in microseconds
227 *
228 * @var int
229 * @access private
230 */
231 public $_timeout_microseconds;
232
233 /**
234 * Connect timeout in seconds
235 */
236 public $_connect_timeout;
237
238 /**
239 * Number of connection attempts for each server
240 */
241 public $_connect_attempts;
242
243 /**
244 * @var LoggerInterface
245 */
246 private $_logger;
247
248 // }}}
249 // }}}
250 // {{{ methods
251 // {{{ public functions
252 // {{{ memcached()
253
254 /**
255 * Memcache initializer
256 *
257 * @param array $args Associative array of settings
258 *
259 * @return mixed
260 */
261 public function __construct( $args ) {
262 $this->set_servers( isset( $args['servers'] ) ? $args['servers'] : array() );
263 $this->_debug = isset( $args['debug'] ) ? $args['debug'] : false;
264 $this->stats = array();
265 $this->_compress_threshold = isset( $args['compress_threshold'] ) ? $args['compress_threshold'] : 0;
266 $this->_persistent = isset( $args['persistent'] ) ? $args['persistent'] : false;
267 $this->_compress_enable = true;
268 $this->_have_zlib = function_exists( 'gzcompress' );
269
270 $this->_cache_sock = array();
271 $this->_host_dead = array();
272
273 $this->_timeout_seconds = 0;
274 $this->_timeout_microseconds = isset( $args['timeout'] ) ? $args['timeout'] : 500000;
275
276 $this->_connect_timeout = isset( $args['connect_timeout'] ) ? $args['connect_timeout'] : 0.1;
277 $this->_connect_attempts = 2;
278
279 $this->_logger = isset( $args['logger'] ) ? $args['logger'] : new NullLogger();
280 }
281
282 // }}}
283 // {{{ add()
284
285 /**
286 * Adds a key/value to the memcache server if one isn't already set with
287 * that key
288 *
289 * @param string $key Key to set with data
290 * @param mixed $val Value to store
291 * @param int $exp (optional) Expiration time. This can be a number of seconds
292 * to cache for (up to 30 days inclusive). Any timespans of 30 days + 1 second or
293 * longer must be the timestamp of the time at which the mapping should expire. It
294 * is safe to use timestamps in all cases, regardless of expiration
295 * eg: strtotime("+3 hour")
296 *
297 * @return bool
298 */
299 public function add( $key, $val, $exp = 0 ) {
300 return $this->_set( 'add', $key, $val, $exp );
301 }
302
303 // }}}
304 // {{{ decr()
305
306 /**
307 * Decrease a value stored on the memcache server
308 *
309 * @param string $key Key to decrease
310 * @param int $amt (optional) amount to decrease
311 *
312 * @return mixed False on failure, value on success
313 */
314 public function decr( $key, $amt = 1 ) {
315 return $this->_incrdecr( 'decr', $key, $amt );
316 }
317
318 // }}}
319 // {{{ delete()
320
321 /**
322 * Deletes a key from the server, optionally after $time
323 *
324 * @param string $key Key to delete
325 * @param int $time (optional) how long to wait before deleting
326 *
327 * @return bool True on success, false on failure
328 */
329 public function delete( $key, $time = 0 ) {
330 if ( !$this->_active ) {
331 return false;
332 }
333
334 $sock = $this->get_sock( $key );
335 if ( !is_resource( $sock ) ) {
336 return false;
337 }
338
339 $key = is_array( $key ) ? $key[1] : $key;
340
341 if ( isset( $this->stats['delete'] ) ) {
342 $this->stats['delete']++;
343 } else {
344 $this->stats['delete'] = 1;
345 }
346 $cmd = "delete $key $time\r\n";
347 if ( !$this->_fwrite( $sock, $cmd ) ) {
348 return false;
349 }
350 $res = $this->_fgets( $sock );
351
352 if ( $this->_debug ) {
353 $this->_debugprint( sprintf( "MemCache: delete %s (%s)\n", $key, $res ) );
354 }
355
356 if ( $res == "DELETED" || $res == "NOT_FOUND" ) {
357 return true;
358 }
359
360 return false;
361 }
362
363 /**
364 * @param string $key
365 * @param int $timeout
366 * @return bool
367 */
368 public function lock( $key, $timeout = 0 ) {
369 /* stub */
370 return true;
371 }
372
373 /**
374 * @param string $key
375 * @return bool
376 */
377 public function unlock( $key ) {
378 /* stub */
379 return true;
380 }
381
382 // }}}
383 // {{{ disconnect_all()
384
385 /**
386 * Disconnects all connected sockets
387 */
388 public function disconnect_all() {
389 foreach ( $this->_cache_sock as $sock ) {
390 fclose( $sock );
391 }
392
393 $this->_cache_sock = array();
394 }
395
396 // }}}
397 // {{{ enable_compress()
398
399 /**
400 * Enable / Disable compression
401 *
402 * @param bool $enable True to enable, false to disable
403 */
404 public function enable_compress( $enable ) {
405 $this->_compress_enable = $enable;
406 }
407
408 // }}}
409 // {{{ forget_dead_hosts()
410
411 /**
412 * Forget about all of the dead hosts
413 */
414 public function forget_dead_hosts() {
415 $this->_host_dead = array();
416 }
417
418 // }}}
419 // {{{ get()
420
421 /**
422 * Retrieves the value associated with the key from the memcache server
423 *
424 * @param array|string $key key to retrieve
425 * @param float $casToken [optional]
426 *
427 * @return mixed
428 */
429 public function get( $key, &$casToken = null ) {
430
431 if ( $this->_debug ) {
432 $this->_debugprint( "get($key)\n" );
433 }
434
435 if ( !is_array( $key ) && strval( $key ) === '' ) {
436 $this->_debugprint( "Skipping key which equals to an empty string" );
437 return false;
438 }
439
440 if ( !$this->_active ) {
441 return false;
442 }
443
444 $sock = $this->get_sock( $key );
445
446 if ( !is_resource( $sock ) ) {
447 return false;
448 }
449
450 $key = is_array( $key ) ? $key[1] : $key;
451 if ( isset( $this->stats['get'] ) ) {
452 $this->stats['get']++;
453 } else {
454 $this->stats['get'] = 1;
455 }
456
457 $cmd = "gets $key\r\n";
458 if ( !$this->_fwrite( $sock, $cmd ) ) {
459 return false;
460 }
461
462 $val = array();
463 $this->_load_items( $sock, $val, $casToken );
464
465 if ( $this->_debug ) {
466 foreach ( $val as $k => $v ) {
467 $this->_debugprint( sprintf( "MemCache: sock %s got %s\n", serialize( $sock ), $k ) );
468 }
469 }
470
471 $value = false;
472 if ( isset( $val[$key] ) ) {
473 $value = $val[$key];
474 }
475 return $value;
476 }
477
478 // }}}
479 // {{{ get_multi()
480
481 /**
482 * Get multiple keys from the server(s)
483 *
484 * @param array $keys Keys to retrieve
485 *
486 * @return array
487 */
488 public function get_multi( $keys ) {
489 if ( !$this->_active ) {
490 return false;
491 }
492
493 if ( isset( $this->stats['get_multi'] ) ) {
494 $this->stats['get_multi']++;
495 } else {
496 $this->stats['get_multi'] = 1;
497 }
498 $sock_keys = array();
499 $socks = array();
500 foreach ( $keys as $key ) {
501 $sock = $this->get_sock( $key );
502 if ( !is_resource( $sock ) ) {
503 continue;
504 }
505 $key = is_array( $key ) ? $key[1] : $key;
506 if ( !isset( $sock_keys[$sock] ) ) {
507 $sock_keys[intval( $sock )] = array();
508 $socks[] = $sock;
509 }
510 $sock_keys[intval( $sock )][] = $key;
511 }
512
513 $gather = array();
514 // Send out the requests
515 foreach ( $socks as $sock ) {
516 $cmd = 'gets';
517 foreach ( $sock_keys[intval( $sock )] as $key ) {
518 $cmd .= ' ' . $key;
519 }
520 $cmd .= "\r\n";
521
522 if ( $this->_fwrite( $sock, $cmd ) ) {
523 $gather[] = $sock;
524 }
525 }
526
527 // Parse responses
528 $val = array();
529 foreach ( $gather as $sock ) {
530 $this->_load_items( $sock, $val, $casToken );
531 }
532
533 if ( $this->_debug ) {
534 foreach ( $val as $k => $v ) {
535 $this->_debugprint( sprintf( "MemCache: got %s\n", $k ) );
536 }
537 }
538
539 return $val;
540 }
541
542 // }}}
543 // {{{ incr()
544
545 /**
546 * Increments $key (optionally) by $amt
547 *
548 * @param string $key Key to increment
549 * @param int $amt (optional) amount to increment
550 *
551 * @return int|null Null if the key does not exist yet (this does NOT
552 * create new mappings if the key does not exist). If the key does
553 * exist, this returns the new value for that key.
554 */
555 public function incr( $key, $amt = 1 ) {
556 return $this->_incrdecr( 'incr', $key, $amt );
557 }
558
559 // }}}
560 // {{{ replace()
561
562 /**
563 * Overwrites an existing value for key; only works if key is already set
564 *
565 * @param string $key Key to set value as
566 * @param mixed $value Value to store
567 * @param int $exp (optional) Expiration time. This can be a number of seconds
568 * to cache for (up to 30 days inclusive). Any timespans of 30 days + 1 second or
569 * longer must be the timestamp of the time at which the mapping should expire. It
570 * is safe to use timestamps in all cases, regardless of exipration
571 * eg: strtotime("+3 hour")
572 *
573 * @return bool
574 */
575 public function replace( $key, $value, $exp = 0 ) {
576 return $this->_set( 'replace', $key, $value, $exp );
577 }
578
579 // }}}
580 // {{{ run_command()
581
582 /**
583 * Passes through $cmd to the memcache server connected by $sock; returns
584 * output as an array (null array if no output)
585 *
586 * @param Resource $sock Socket to send command on
587 * @param string $cmd Command to run
588 *
589 * @return array Output array
590 */
591 public function run_command( $sock, $cmd ) {
592 if ( !is_resource( $sock ) ) {
593 return array();
594 }
595
596 if ( !$this->_fwrite( $sock, $cmd ) ) {
597 return array();
598 }
599
600 $ret = array();
601 while ( true ) {
602 $res = $this->_fgets( $sock );
603 $ret[] = $res;
604 if ( preg_match( '/^END/', $res ) ) {
605 break;
606 }
607 if ( strlen( $res ) == 0 ) {
608 break;
609 }
610 }
611 return $ret;
612 }
613
614 // }}}
615 // {{{ set()
616
617 /**
618 * Unconditionally sets a key to a given value in the memcache. Returns true
619 * if set successfully.
620 *
621 * @param string $key Key to set value as
622 * @param mixed $value Value to set
623 * @param int $exp (optional) Expiration time. This can be a number of seconds
624 * to cache for (up to 30 days inclusive). Any timespans of 30 days + 1 second or
625 * longer must be the timestamp of the time at which the mapping should expire. It
626 * is safe to use timestamps in all cases, regardless of exipration
627 * eg: strtotime("+3 hour")
628 *
629 * @return bool True on success
630 */
631 public function set( $key, $value, $exp = 0 ) {
632 return $this->_set( 'set', $key, $value, $exp );
633 }
634
635 // }}}
636 // {{{ cas()
637
638 /**
639 * Sets a key to a given value in the memcache if the current value still corresponds
640 * to a known, given value. Returns true if set successfully.
641 *
642 * @param float $casToken Current known value
643 * @param string $key Key to set value as
644 * @param mixed $value Value to set
645 * @param int $exp (optional) Expiration time. This can be a number of seconds
646 * to cache for (up to 30 days inclusive). Any timespans of 30 days + 1 second or
647 * longer must be the timestamp of the time at which the mapping should expire. It
648 * is safe to use timestamps in all cases, regardless of exipration
649 * eg: strtotime("+3 hour")
650 *
651 * @return bool True on success
652 */
653 public function cas( $casToken, $key, $value, $exp = 0 ) {
654 return $this->_set( 'cas', $key, $value, $exp, $casToken );
655 }
656
657 // }}}
658 // {{{ set_compress_threshold()
659
660 /**
661 * Set the compression threshold
662 *
663 * @param int $thresh Threshold to compress if larger than
664 */
665 public function set_compress_threshold( $thresh ) {
666 $this->_compress_threshold = $thresh;
667 }
668
669 // }}}
670 // {{{ set_debug()
671
672 /**
673 * Set the debug flag
674 *
675 * @see __construct()
676 * @param bool $dbg True for debugging, false otherwise
677 */
678 public function set_debug( $dbg ) {
679 $this->_debug = $dbg;
680 }
681
682 // }}}
683 // {{{ set_servers()
684
685 /**
686 * Set the server list to distribute key gets and puts between
687 *
688 * @see __construct()
689 * @param array $list Array of servers to connect to
690 */
691 public function set_servers( $list ) {
692 $this->_servers = $list;
693 $this->_active = count( $list );
694 $this->_buckets = null;
695 $this->_bucketcount = 0;
696
697 $this->_single_sock = null;
698 if ( $this->_active == 1 ) {
699 $this->_single_sock = $this->_servers[0];
700 }
701 }
702
703 /**
704 * Sets the timeout for new connections
705 *
706 * @param int $seconds Number of seconds
707 * @param int $microseconds Number of microseconds
708 */
709 public function set_timeout( $seconds, $microseconds ) {
710 $this->_timeout_seconds = $seconds;
711 $this->_timeout_microseconds = $microseconds;
712 }
713
714 // }}}
715 // }}}
716 // {{{ private methods
717 // {{{ _close_sock()
718
719 /**
720 * Close the specified socket
721 *
722 * @param string $sock Socket to close
723 *
724 * @access private
725 */
726 function _close_sock( $sock ) {
727 $host = array_search( $sock, $this->_cache_sock );
728 fclose( $this->_cache_sock[$host] );
729 unset( $this->_cache_sock[$host] );
730 }
731
732 // }}}
733 // {{{ _connect_sock()
734
735 /**
736 * Connects $sock to $host, timing out after $timeout
737 *
738 * @param int $sock Socket to connect
739 * @param string $host Host:IP to connect to
740 *
741 * @return bool
742 * @access private
743 */
744 function _connect_sock( &$sock, $host ) {
745 list( $ip, $port ) = preg_split( '/:(?=\d)/', $host );
746 $sock = false;
747 $timeout = $this->_connect_timeout;
748 $errno = $errstr = null;
749 for ( $i = 0; !$sock && $i < $this->_connect_attempts; $i++ ) {
750 MediaWiki\suppressWarnings();
751 if ( $this->_persistent == 1 ) {
752 $sock = pfsockopen( $ip, $port, $errno, $errstr, $timeout );
753 } else {
754 $sock = fsockopen( $ip, $port, $errno, $errstr, $timeout );
755 }
756 MediaWiki\restoreWarnings();
757 }
758 if ( !$sock ) {
759 $this->_error_log( "Error connecting to $host: $errstr\n" );
760 $this->_dead_host( $host );
761 return false;
762 }
763
764 // Initialise timeout
765 stream_set_timeout( $sock, $this->_timeout_seconds, $this->_timeout_microseconds );
766
767 // If the connection was persistent, flush the read buffer in case there
768 // was a previous incomplete request on this connection
769 if ( $this->_persistent ) {
770 $this->_flush_read_buffer( $sock );
771 }
772 return true;
773 }
774
775 // }}}
776 // {{{ _dead_sock()
777
778 /**
779 * Marks a host as dead until 30-40 seconds in the future
780 *
781 * @param string $sock Socket to mark as dead
782 *
783 * @access private
784 */
785 function _dead_sock( $sock ) {
786 $host = array_search( $sock, $this->_cache_sock );
787 $this->_dead_host( $host );
788 }
789
790 /**
791 * @param string $host
792 */
793 function _dead_host( $host ) {
794 $parts = explode( ':', $host );
795 $ip = $parts[0];
796 $this->_host_dead[$ip] = time() + 30 + intval( rand( 0, 10 ) );
797 $this->_host_dead[$host] = $this->_host_dead[$ip];
798 unset( $this->_cache_sock[$host] );
799 }
800
801 // }}}
802 // {{{ get_sock()
803
804 /**
805 * get_sock
806 *
807 * @param string $key Key to retrieve value for;
808 *
809 * @return Resource|bool Resource on success, false on failure
810 * @access private
811 */
812 function get_sock( $key ) {
813 if ( !$this->_active ) {
814 return false;
815 }
816
817 if ( $this->_single_sock !== null ) {
818 return $this->sock_to_host( $this->_single_sock );
819 }
820
821 $hv = is_array( $key ) ? intval( $key[0] ) : $this->_hashfunc( $key );
822 if ( $this->_buckets === null ) {
823 $bu = array();
824 foreach ( $this->_servers as $v ) {
825 if ( is_array( $v ) ) {
826 for ( $i = 0; $i < $v[1]; $i++ ) {
827 $bu[] = $v[0];
828 }
829 } else {
830 $bu[] = $v;
831 }
832 }
833 $this->_buckets = $bu;
834 $this->_bucketcount = count( $bu );
835 }
836
837 $realkey = is_array( $key ) ? $key[1] : $key;
838 for ( $tries = 0; $tries < 20; $tries++ ) {
839 $host = $this->_buckets[$hv % $this->_bucketcount];
840 $sock = $this->sock_to_host( $host );
841 if ( is_resource( $sock ) ) {
842 return $sock;
843 }
844 $hv = $this->_hashfunc( $hv . $realkey );
845 }
846
847 return false;
848 }
849
850 // }}}
851 // {{{ _hashfunc()
852
853 /**
854 * Creates a hash integer based on the $key
855 *
856 * @param string $key Key to hash
857 *
858 * @return int Hash value
859 * @access private
860 */
861 function _hashfunc( $key ) {
862 # Hash function must be in [0,0x7ffffff]
863 # We take the first 31 bits of the MD5 hash, which unlike the hash
864 # function used in a previous version of this client, works
865 return hexdec( substr( md5( $key ), 0, 8 ) ) & 0x7fffffff;
866 }
867
868 // }}}
869 // {{{ _incrdecr()
870
871 /**
872 * Perform increment/decriment on $key
873 *
874 * @param string $cmd Command to perform
875 * @param string|array $key Key to perform it on
876 * @param int $amt Amount to adjust
877 *
878 * @return int New value of $key
879 * @access private
880 */
881 function _incrdecr( $cmd, $key, $amt = 1 ) {
882 if ( !$this->_active ) {
883 return null;
884 }
885
886 $sock = $this->get_sock( $key );
887 if ( !is_resource( $sock ) ) {
888 return null;
889 }
890
891 $key = is_array( $key ) ? $key[1] : $key;
892 if ( isset( $this->stats[$cmd] ) ) {
893 $this->stats[$cmd]++;
894 } else {
895 $this->stats[$cmd] = 1;
896 }
897 if ( !$this->_fwrite( $sock, "$cmd $key $amt\r\n" ) ) {
898 return null;
899 }
900
901 $line = $this->_fgets( $sock );
902 $match = array();
903 if ( !preg_match( '/^(\d+)/', $line, $match ) ) {
904 return null;
905 }
906 return $match[1];
907 }
908
909 // }}}
910 // {{{ _load_items()
911
912 /**
913 * Load items into $ret from $sock
914 *
915 * @param Resource $sock Socket to read from
916 * @param array $ret returned values
917 * @param float $casToken [optional]
918 * @return bool True for success, false for failure
919 *
920 * @access private
921 */
922 function _load_items( $sock, &$ret, &$casToken = null ) {
923 $results = array();
924
925 while ( 1 ) {
926 $decl = $this->_fgets( $sock );
927
928 if ( $decl === false ) {
929 /*
930 * If nothing can be read, something is wrong because we know exactly when
931 * to stop reading (right after "END") and we return right after that.
932 */
933 return false;
934 } elseif ( preg_match( '/^VALUE (\S+) (\d+) (\d+) (\d+)$/', $decl, $match ) ) {
935 /*
936 * Read all data returned. This can be either one or multiple values.
937 * Save all that data (in an array) to be processed later: we'll first
938 * want to continue reading until "END" before doing anything else,
939 * to make sure that we don't leave our client in a state where it's
940 * output is not yet fully read.
941 */
942 $results[] = array(
943 $match[1], // rkey
944 $match[2], // flags
945 $match[3], // len
946 $match[4], // casToken
947 $this->_fread( $sock, $match[3] + 2 ), // data
948 );
949 } elseif ( $decl == "END" ) {
950 if ( count( $results ) == 0 ) {
951 return false;
952 }
953
954 /**
955 * All data has been read, time to process the data and build
956 * meaningful return values.
957 */
958 foreach ( $results as $vars ) {
959 list( $rkey, $flags, $len, $casToken, $data ) = $vars;
960
961 if ( $data === false || substr( $data, -2 ) !== "\r\n" ) {
962 $this->_handle_error( $sock,
963 'line ending missing from data block from $1' );
964 return false;
965 }
966 $data = substr( $data, 0, -2 );
967 $ret[$rkey] = $data;
968
969 if ( $this->_have_zlib && $flags & self::COMPRESSED ) {
970 $ret[$rkey] = gzuncompress( $ret[$rkey] );
971 }
972
973 /*
974 * This unserialize is the exact reason that we only want to
975 * process data after having read until "END" (instead of doing
976 * this right away): "unserialize" can trigger outside code:
977 * in the event that $ret[$rkey] is a serialized object,
978 * unserializing it will trigger __wakeup() if present. If that
979 * function attempted to read from memcached (while we did not
980 * yet read "END"), these 2 calls would collide.
981 */
982 if ( $flags & self::SERIALIZED ) {
983 $ret[$rkey] = unserialize( $ret[$rkey] );
984 } elseif ( $flags & self::INTVAL ) {
985 $ret[$rkey] = intval( $ret[$rkey] );
986 }
987 }
988
989 return true;
990 } else {
991 $this->_handle_error( $sock, 'Error parsing response from $1' );
992 return false;
993 }
994 }
995 }
996
997 // }}}
998 // {{{ _set()
999
1000 /**
1001 * Performs the requested storage operation to the memcache server
1002 *
1003 * @param string $cmd Command to perform
1004 * @param string $key Key to act on
1005 * @param mixed $val What we need to store
1006 * @param int $exp (optional) Expiration time. This can be a number of seconds
1007 * to cache for (up to 30 days inclusive). Any timespans of 30 days + 1 second or
1008 * longer must be the timestamp of the time at which the mapping should expire. It
1009 * is safe to use timestamps in all cases, regardless of exipration
1010 * eg: strtotime("+3 hour")
1011 * @param float $casToken [optional]
1012 *
1013 * @return bool
1014 * @access private
1015 */
1016 function _set( $cmd, $key, $val, $exp, $casToken = null ) {
1017 if ( !$this->_active ) {
1018 return false;
1019 }
1020
1021 $sock = $this->get_sock( $key );
1022 if ( !is_resource( $sock ) ) {
1023 return false;
1024 }
1025
1026 if ( isset( $this->stats[$cmd] ) ) {
1027 $this->stats[$cmd]++;
1028 } else {
1029 $this->stats[$cmd] = 1;
1030 }
1031
1032 $flags = 0;
1033
1034 if ( is_int( $val ) ) {
1035 $flags |= self::INTVAL;
1036 } elseif ( !is_scalar( $val ) ) {
1037 $val = serialize( $val );
1038 $flags |= self::SERIALIZED;
1039 if ( $this->_debug ) {
1040 $this->_debugprint( sprintf( "client: serializing data as it is not scalar\n" ) );
1041 }
1042 }
1043
1044 $len = strlen( $val );
1045
1046 if ( $this->_have_zlib && $this->_compress_enable
1047 && $this->_compress_threshold && $len >= $this->_compress_threshold
1048 ) {
1049 $c_val = gzcompress( $val, 9 );
1050 $c_len = strlen( $c_val );
1051
1052 if ( $c_len < $len * ( 1 - self::COMPRESSION_SAVINGS ) ) {
1053 if ( $this->_debug ) {
1054 $this->_debugprint( sprintf( "client: compressing data; was %d bytes is now %d bytes\n", $len, $c_len ) );
1055 }
1056 $val = $c_val;
1057 $len = $c_len;
1058 $flags |= self::COMPRESSED;
1059 }
1060 }
1061
1062 $command = "$cmd $key $flags $exp $len";
1063 if ( $casToken ) {
1064 $command .= " $casToken";
1065 }
1066
1067 if ( !$this->_fwrite( $sock, "$command\r\n$val\r\n" ) ) {
1068 return false;
1069 }
1070
1071 $line = $this->_fgets( $sock );
1072
1073 if ( $this->_debug ) {
1074 $this->_debugprint( sprintf( "%s %s (%s)\n", $cmd, $key, $line ) );
1075 }
1076 if ( $line == "STORED" ) {
1077 return true;
1078 }
1079 return false;
1080 }
1081
1082 // }}}
1083 // {{{ sock_to_host()
1084
1085 /**
1086 * Returns the socket for the host
1087 *
1088 * @param string $host Host:IP to get socket for
1089 *
1090 * @return Resource|bool IO Stream or false
1091 * @access private
1092 */
1093 function sock_to_host( $host ) {
1094 if ( isset( $this->_cache_sock[$host] ) ) {
1095 return $this->_cache_sock[$host];
1096 }
1097
1098 $sock = null;
1099 $now = time();
1100 list( $ip, /* $port */) = explode( ':', $host );
1101 if ( isset( $this->_host_dead[$host] ) && $this->_host_dead[$host] > $now ||
1102 isset( $this->_host_dead[$ip] ) && $this->_host_dead[$ip] > $now
1103 ) {
1104 return null;
1105 }
1106
1107 if ( !$this->_connect_sock( $sock, $host ) ) {
1108 return null;
1109 }
1110
1111 // Do not buffer writes
1112 stream_set_write_buffer( $sock, 0 );
1113
1114 $this->_cache_sock[$host] = $sock;
1115
1116 return $this->_cache_sock[$host];
1117 }
1118
1119 /**
1120 * @param string $text
1121 */
1122 function _debugprint( $text ) {
1123 $this->_logger->debug( $text );
1124 }
1125
1126 /**
1127 * @param string $text
1128 */
1129 function _error_log( $text ) {
1130 $this->_logger->error( "Memcached error: $text" );
1131 }
1132
1133 /**
1134 * Write to a stream. If there is an error, mark the socket dead.
1135 *
1136 * @param Resource $sock The socket
1137 * @param string $buf The string to write
1138 * @return bool True on success, false on failure
1139 */
1140 function _fwrite( $sock, $buf ) {
1141 $bytesWritten = 0;
1142 $bufSize = strlen( $buf );
1143 while ( $bytesWritten < $bufSize ) {
1144 $result = fwrite( $sock, $buf );
1145 $data = stream_get_meta_data( $sock );
1146 if ( $data['timed_out'] ) {
1147 $this->_handle_error( $sock, 'timeout writing to $1' );
1148 return false;
1149 }
1150 // Contrary to the documentation, fwrite() returns zero on error in PHP 5.3.
1151 if ( $result === false || $result === 0 ) {
1152 $this->_handle_error( $sock, 'error writing to $1' );
1153 return false;
1154 }
1155 $bytesWritten += $result;
1156 }
1157
1158 return true;
1159 }
1160
1161 /**
1162 * Handle an I/O error. Mark the socket dead and log an error.
1163 *
1164 * @param Resource $sock
1165 * @param string $msg
1166 */
1167 function _handle_error( $sock, $msg ) {
1168 $peer = stream_socket_get_name( $sock, true /** remote **/ );
1169 if ( strval( $peer ) === '' ) {
1170 $peer = array_search( $sock, $this->_cache_sock );
1171 if ( $peer === false ) {
1172 $peer = '[unknown host]';
1173 }
1174 }
1175 $msg = str_replace( '$1', $peer, $msg );
1176 $this->_error_log( "$msg\n" );
1177 $this->_dead_sock( $sock );
1178 }
1179
1180 /**
1181 * Read the specified number of bytes from a stream. If there is an error,
1182 * mark the socket dead.
1183 *
1184 * @param Resource $sock The socket
1185 * @param int $len The number of bytes to read
1186 * @return string|bool The string on success, false on failure.
1187 */
1188 function _fread( $sock, $len ) {
1189 $buf = '';
1190 while ( $len > 0 ) {
1191 $result = fread( $sock, $len );
1192 $data = stream_get_meta_data( $sock );
1193 if ( $data['timed_out'] ) {
1194 $this->_handle_error( $sock, 'timeout reading from $1' );
1195 return false;
1196 }
1197 if ( $result === false ) {
1198 $this->_handle_error( $sock, 'error reading buffer from $1' );
1199 return false;
1200 }
1201 if ( $result === '' ) {
1202 // This will happen if the remote end of the socket is shut down
1203 $this->_handle_error( $sock, 'unexpected end of file reading from $1' );
1204 return false;
1205 }
1206 $len -= strlen( $result );
1207 $buf .= $result;
1208 }
1209 return $buf;
1210 }
1211
1212 /**
1213 * Read a line from a stream. If there is an error, mark the socket dead.
1214 * The \r\n line ending is stripped from the response.
1215 *
1216 * @param Resource $sock The socket
1217 * @return string|bool The string on success, false on failure
1218 */
1219 function _fgets( $sock ) {
1220 $result = fgets( $sock );
1221 // fgets() may return a partial line if there is a select timeout after
1222 // a successful recv(), so we have to check for a timeout even if we
1223 // got a string response.
1224 $data = stream_get_meta_data( $sock );
1225 if ( $data['timed_out'] ) {
1226 $this->_handle_error( $sock, 'timeout reading line from $1' );
1227 return false;
1228 }
1229 if ( $result === false ) {
1230 $this->_handle_error( $sock, 'error reading line from $1' );
1231 return false;
1232 }
1233 if ( substr( $result, -2 ) === "\r\n" ) {
1234 $result = substr( $result, 0, -2 );
1235 } elseif ( substr( $result, -1 ) === "\n" ) {
1236 $result = substr( $result, 0, -1 );
1237 } else {
1238 $this->_handle_error( $sock, 'line ending missing in response from $1' );
1239 return false;
1240 }
1241 return $result;
1242 }
1243
1244 /**
1245 * Flush the read buffer of a stream
1246 * @param Resource $f
1247 */
1248 function _flush_read_buffer( $f ) {
1249 if ( !is_resource( $f ) ) {
1250 return;
1251 }
1252 $r = array( $f );
1253 $w = null;
1254 $e = null;
1255 $n = stream_select( $r, $w, $e, 0, 0 );
1256 while ( $n == 1 && !feof( $f ) ) {
1257 fread( $f, 1024 );
1258 $r = array( $f );
1259 $w = null;
1260 $e = null;
1261 $n = stream_select( $r, $w, $e, 0, 0 );
1262 }
1263 }
1264
1265 // }}}
1266 // }}}
1267 // }}}
1268 }
1269
1270 // }}}
MediaWiki Core