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