?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Expose $wgMaxArticleSize in siteinfo query api
[mediawiki.git] / includes / libs / objectcache / MemcachedClient.php
blob668135d070ca49cd6f98f79ad621a57f78d07820
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)", $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)" );
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", 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 array();
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", $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" );
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 $ip = explode( ':', $host )[0];
795 $this->_host_dead[$ip] = time() + 30 + intval( rand( 0, 10 ) );
796 $this->_host_dead[$host] = $this->_host_dead[$ip];
797 unset( $this->_cache_sock[$host] );
798 }
799
800 // }}}
801 // {{{ get_sock()
802
803 /**
804 * get_sock
805 *
806 * @param string $key Key to retrieve value for;
807 *
808 * @return Resource|bool Resource on success, false on failure
809 * @access private
810 */
811 function get_sock( $key ) {
812 if ( !$this->_active ) {
813 return false;
814 }
815
816 if ( $this->_single_sock !== null ) {
817 return $this->sock_to_host( $this->_single_sock );
818 }
819
820 $hv = is_array( $key ) ? intval( $key[0] ) : $this->_hashfunc( $key );
821 if ( $this->_buckets === null ) {
822 $bu = array();
823 foreach ( $this->_servers as $v ) {
824 if ( is_array( $v ) ) {
825 for ( $i = 0; $i < $v[1]; $i++ ) {
826 $bu[] = $v[0];
827 }
828 } else {
829 $bu[] = $v;
830 }
831 }
832 $this->_buckets = $bu;
833 $this->_bucketcount = count( $bu );
834 }
835
836 $realkey = is_array( $key ) ? $key[1] : $key;
837 for ( $tries = 0; $tries < 20; $tries++ ) {
838 $host = $this->_buckets[$hv % $this->_bucketcount];
839 $sock = $this->sock_to_host( $host );
840 if ( is_resource( $sock ) ) {
841 return $sock;
842 }
843 $hv = $this->_hashfunc( $hv . $realkey );
844 }
845
846 return false;
847 }
848
849 // }}}
850 // {{{ _hashfunc()
851
852 /**
853 * Creates a hash integer based on the $key
854 *
855 * @param string $key Key to hash
856 *
857 * @return int Hash value
858 * @access private
859 */
860 function _hashfunc( $key ) {
861 # Hash function must be in [0,0x7ffffff]
862 # We take the first 31 bits of the MD5 hash, which unlike the hash
863 # function used in a previous version of this client, works
864 return hexdec( substr( md5( $key ), 0, 8 ) ) & 0x7fffffff;
865 }
866
867 // }}}
868 // {{{ _incrdecr()
869
870 /**
871 * Perform increment/decriment on $key
872 *
873 * @param string $cmd Command to perform
874 * @param string|array $key Key to perform it on
875 * @param int $amt Amount to adjust
876 *
877 * @return int New value of $key
878 * @access private
879 */
880 function _incrdecr( $cmd, $key, $amt = 1 ) {
881 if ( !$this->_active ) {
882 return null;
883 }
884
885 $sock = $this->get_sock( $key );
886 if ( !is_resource( $sock ) ) {
887 return null;
888 }
889
890 $key = is_array( $key ) ? $key[1] : $key;
891 if ( isset( $this->stats[$cmd] ) ) {
892 $this->stats[$cmd]++;
893 } else {
894 $this->stats[$cmd] = 1;
895 }
896 if ( !$this->_fwrite( $sock, "$cmd $key $amt\r\n" ) ) {
897 return null;
898 }
899
900 $line = $this->_fgets( $sock );
901 $match = array();
902 if ( !preg_match( '/^(\d+)/', $line, $match ) ) {
903 return null;
904 }
905 return $match[1];
906 }
907
908 // }}}
909 // {{{ _load_items()
910
911 /**
912 * Load items into $ret from $sock
913 *
914 * @param Resource $sock Socket to read from
915 * @param array $ret returned values
916 * @param float $casToken [optional]
917 * @return bool True for success, false for failure
918 *
919 * @access private
920 */
921 function _load_items( $sock, &$ret, &$casToken = null ) {
922 $results = array();
923
924 while ( 1 ) {
925 $decl = $this->_fgets( $sock );
926
927 if ( $decl === false ) {
928 /*
929 * If nothing can be read, something is wrong because we know exactly when
930 * to stop reading (right after "END") and we return right after that.
931 */
932 return false;
933 } elseif ( preg_match( '/^VALUE (\S+) (\d+) (\d+) (\d+)$/', $decl, $match ) ) {
934 /*
935 * Read all data returned. This can be either one or multiple values.
936 * Save all that data (in an array) to be processed later: we'll first
937 * want to continue reading until "END" before doing anything else,
938 * to make sure that we don't leave our client in a state where it's
939 * output is not yet fully read.
940 */
941 $results[] = array(
942 $match[1], // rkey
943 $match[2], // flags
944 $match[3], // len
945 $match[4], // casToken
946 $this->_fread( $sock, $match[3] + 2 ), // data
947 );
948 } elseif ( $decl == "END" ) {
949 if ( count( $results ) == 0 ) {
950 return false;
951 }
952
953 /**
954 * All data has been read, time to process the data and build
955 * meaningful return values.
956 */
957 foreach ( $results as $vars ) {
958 list( $rkey, $flags, $len, $casToken, $data ) = $vars;
959
960 if ( $data === false || substr( $data, -2 ) !== "\r\n" ) {
961 $this->_handle_error( $sock,
962 'line ending missing from data block from $1' );
963 return false;
964 }
965 $data = substr( $data, 0, -2 );
966 $ret[$rkey] = $data;
967
968 if ( $this->_have_zlib && $flags & self::COMPRESSED ) {
969 $ret[$rkey] = gzuncompress( $ret[$rkey] );
970 }
971
972 /*
973 * This unserialize is the exact reason that we only want to
974 * process data after having read until "END" (instead of doing
975 * this right away): "unserialize" can trigger outside code:
976 * in the event that $ret[$rkey] is a serialized object,
977 * unserializing it will trigger __wakeup() if present. If that
978 * function attempted to read from memcached (while we did not
979 * yet read "END"), these 2 calls would collide.
980 */
981 if ( $flags & self::SERIALIZED ) {
982 $ret[$rkey] = unserialize( $ret[$rkey] );
983 } elseif ( $flags & self::INTVAL ) {
984 $ret[$rkey] = intval( $ret[$rkey] );
985 }
986 }
987
988 return true;
989 } else {
990 $this->_handle_error( $sock, 'Error parsing response from $1' );
991 return false;
992 }
993 }
994 }
995
996 // }}}
997 // {{{ _set()
998
999 /**
1000 * Performs the requested storage operation to the memcache server
1001 *
1002 * @param string $cmd Command to perform
1003 * @param string $key Key to act on
1004 * @param mixed $val What we need to store
1005 * @param int $exp (optional) Expiration time. This can be a number of seconds
1006 * to cache for (up to 30 days inclusive). Any timespans of 30 days + 1 second or
1007 * longer must be the timestamp of the time at which the mapping should expire. It
1008 * is safe to use timestamps in all cases, regardless of exipration
1009 * eg: strtotime("+3 hour")
1010 * @param float $casToken [optional]
1011 *
1012 * @return bool
1013 * @access private
1014 */
1015 function _set( $cmd, $key, $val, $exp, $casToken = null ) {
1016 if ( !$this->_active ) {
1017 return false;
1018 }
1019
1020 $sock = $this->get_sock( $key );
1021 if ( !is_resource( $sock ) ) {
1022 return false;
1023 }
1024
1025 if ( isset( $this->stats[$cmd] ) ) {
1026 $this->stats[$cmd]++;
1027 } else {
1028 $this->stats[$cmd] = 1;
1029 }
1030
1031 $flags = 0;
1032
1033 if ( is_int( $val ) ) {
1034 $flags |= self::INTVAL;
1035 } elseif ( !is_scalar( $val ) ) {
1036 $val = serialize( $val );
1037 $flags |= self::SERIALIZED;
1038 if ( $this->_debug ) {
1039 $this->_debugprint( sprintf( "client: serializing data as it is not scalar" ) );
1040 }
1041 }
1042
1043 $len = strlen( $val );
1044
1045 if ( $this->_have_zlib && $this->_compress_enable
1046 && $this->_compress_threshold && $len >= $this->_compress_threshold
1047 ) {
1048 $c_val = gzcompress( $val, 9 );
1049 $c_len = strlen( $c_val );
1050
1051 if ( $c_len < $len * ( 1 - self::COMPRESSION_SAVINGS ) ) {
1052 if ( $this->_debug ) {
1053 $this->_debugprint( sprintf( "client: compressing data; was %d bytes is now %d bytes", $len, $c_len ) );
1054 }
1055 $val = $c_val;
1056 $len = $c_len;
1057 $flags |= self::COMPRESSED;
1058 }
1059 }
1060
1061 $command = "$cmd $key $flags $exp $len";
1062 if ( $casToken ) {
1063 $command .= " $casToken";
1064 }
1065
1066 if ( !$this->_fwrite( $sock, "$command\r\n$val\r\n" ) ) {
1067 return false;
1068 }
1069
1070 $line = $this->_fgets( $sock );
1071
1072 if ( $this->_debug ) {
1073 $this->_debugprint( sprintf( "%s %s (%s)", $cmd, $key, $line ) );
1074 }
1075 if ( $line == "STORED" ) {
1076 return true;
1077 }
1078 return false;
1079 }
1080
1081 // }}}
1082 // {{{ sock_to_host()
1083
1084 /**
1085 * Returns the socket for the host
1086 *
1087 * @param string $host Host:IP to get socket for
1088 *
1089 * @return Resource|bool IO Stream or false
1090 * @access private
1091 */
1092 function sock_to_host( $host ) {
1093 if ( isset( $this->_cache_sock[$host] ) ) {
1094 return $this->_cache_sock[$host];
1095 }
1096
1097 $sock = null;
1098 $now = time();
1099 list( $ip, /* $port */) = explode( ':', $host );
1100 if ( isset( $this->_host_dead[$host] ) && $this->_host_dead[$host] > $now ||
1101 isset( $this->_host_dead[$ip] ) && $this->_host_dead[$ip] > $now
1102 ) {
1103 return null;
1104 }
1105
1106 if ( !$this->_connect_sock( $sock, $host ) ) {
1107 return null;
1108 }
1109
1110 // Do not buffer writes
1111 stream_set_write_buffer( $sock, 0 );
1112
1113 $this->_cache_sock[$host] = $sock;
1114
1115 return $this->_cache_sock[$host];
1116 }
1117
1118 /**
1119 * @param string $text
1120 */
1121 function _debugprint( $text ) {
1122 $this->_logger->debug( $text );
1123 }
1124
1125 /**
1126 * @param string $text
1127 */
1128 function _error_log( $text ) {
1129 $this->_logger->error( "Memcached error: $text" );
1130 }
1131
1132 /**
1133 * Write to a stream. If there is an error, mark the socket dead.
1134 *
1135 * @param Resource $sock The socket
1136 * @param string $buf The string to write
1137 * @return bool True on success, false on failure
1138 */
1139 function _fwrite( $sock, $buf ) {
1140 $bytesWritten = 0;
1141 $bufSize = strlen( $buf );
1142 while ( $bytesWritten < $bufSize ) {
1143 $result = fwrite( $sock, $buf );
1144 $data = stream_get_meta_data( $sock );
1145 if ( $data['timed_out'] ) {
1146 $this->_handle_error( $sock, 'timeout writing to $1' );
1147 return false;
1148 }
1149 // Contrary to the documentation, fwrite() returns zero on error in PHP 5.3.
1150 if ( $result === false || $result === 0 ) {
1151 $this->_handle_error( $sock, 'error writing to $1' );
1152 return false;
1153 }
1154 $bytesWritten += $result;
1155 }
1156
1157 return true;
1158 }
1159
1160 /**
1161 * Handle an I/O error. Mark the socket dead and log an error.
1162 *
1163 * @param Resource $sock
1164 * @param string $msg
1165 */
1166 function _handle_error( $sock, $msg ) {
1167 $peer = stream_socket_get_name( $sock, true /** remote **/ );
1168 if ( strval( $peer ) === '' ) {
1169 $peer = array_search( $sock, $this->_cache_sock );
1170 if ( $peer === false ) {
1171 $peer = '[unknown host]';
1172 }
1173 }
1174 $msg = str_replace( '$1', $peer, $msg );
1175 $this->_error_log( "$msg" );
1176 $this->_dead_sock( $sock );
1177 }
1178
1179 /**
1180 * Read the specified number of bytes from a stream. If there is an error,
1181 * mark the socket dead.
1182 *
1183 * @param Resource $sock The socket
1184 * @param int $len The number of bytes to read
1185 * @return string|bool The string on success, false on failure.
1186 */
1187 function _fread( $sock, $len ) {
1188 $buf = '';
1189 while ( $len > 0 ) {
1190 $result = fread( $sock, $len );
1191 $data = stream_get_meta_data( $sock );
1192 if ( $data['timed_out'] ) {
1193 $this->_handle_error( $sock, 'timeout reading from $1' );
1194 return false;
1195 }
1196 if ( $result === false ) {
1197 $this->_handle_error( $sock, 'error reading buffer from $1' );
1198 return false;
1199 }
1200 if ( $result === '' ) {
1201 // This will happen if the remote end of the socket is shut down
1202 $this->_handle_error( $sock, 'unexpected end of file reading from $1' );
1203 return false;
1204 }
1205 $len -= strlen( $result );
1206 $buf .= $result;
1207 }
1208 return $buf;
1209 }
1210
1211 /**
1212 * Read a line from a stream. If there is an error, mark the socket dead.
1213 * The \r\n line ending is stripped from the response.
1214 *
1215 * @param Resource $sock The socket
1216 * @return string|bool The string on success, false on failure
1217 */
1218 function _fgets( $sock ) {
1219 $result = fgets( $sock );
1220 // fgets() may return a partial line if there is a select timeout after
1221 // a successful recv(), so we have to check for a timeout even if we
1222 // got a string response.
1223 $data = stream_get_meta_data( $sock );
1224 if ( $data['timed_out'] ) {
1225 $this->_handle_error( $sock, 'timeout reading line from $1' );
1226 return false;
1227 }
1228 if ( $result === false ) {
1229 $this->_handle_error( $sock, 'error reading line from $1' );
1230 return false;
1231 }
1232 if ( substr( $result, -2 ) === "\r\n" ) {
1233 $result = substr( $result, 0, -2 );
1234 } elseif ( substr( $result, -1 ) === "\n" ) {
1235 $result = substr( $result, 0, -1 );
1236 } else {
1237 $this->_handle_error( $sock, 'line ending missing in response from $1' );
1238 return false;
1239 }
1240 return $result;
1241 }
1242
1243 /**
1244 * Flush the read buffer of a stream
1245 * @param Resource $f
1246 */
1247 function _flush_read_buffer( $f ) {
1248 if ( !is_resource( $f ) ) {
1249 return;
1250 }
1251 $r = array( $f );
1252 $w = null;
1253 $e = null;
1254 $n = stream_select( $r, $w, $e, 0, 0 );
1255 while ( $n == 1 && !feof( $f ) ) {
1256 fread( $f, 1024 );
1257 $r = array( $f );
1258 $w = null;
1259 $e = null;
1260 $n = stream_select( $r, $w, $e, 0, 0 );
1261 }
1262 }
1263
1264 // }}}
1265 // }}}
1266 // }}}
1267 }
1268
1269 // }}}
MediaWiki Core