includes/libs/objectcache/MemcachedClient.php

   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 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", $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 // }}}