includes/objectcache/MemcachedClient.php

   1 <?php
   2 /**
   3  * Memcached client for PHP.
   4  *
   5  * +---------------------------------------------------------------------------+
   6  * | memcached client, PHP                                                     |
   7  * +---------------------------------------------------------------------------+
   8  * | Copyright (c) 2003 Ryan T. Dean <rtdean@cytherianage.net>                 |
   9  * | All rights reserved.                                                      |
  10  * |                                                                           |
  11  * | Redistribution and use in source and binary forms, with or without        |
  12  * | modification, are permitted provided that the following conditions        |
  13  * | are met:                                                                  |
  14  * |                                                                           |
  15  * | 1. Redistributions of source code must retain the above copyright         |
  16  * |    notice, this list of conditions and the following disclaimer.          |
  17  * | 2. Redistributions in binary form must reproduce the above copyright      |
  18  * |    notice, this list of conditions and the following disclaimer in the    |
  19  * |    documentation and/or other materials provided with the distribution.   |
  20  * |                                                                           |
  21  * | THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR      |
  22  * | IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
  23  * | OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.   |
  24  * | IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,          |
  25  * | INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT  |
  26  * | NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
  27  * | DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY     |
  28  * | THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT       |
  29  * | (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF  |
  30  * | THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.         |
  31  * +---------------------------------------------------------------------------+
  32  * | Author: Ryan T. Dean <rtdean@cytherianage.net>                            |
  33  * | Heavily influenced by the Perl memcached client by Brad Fitzpatrick.      |
  34  * |   Permission granted by Brad Fitzpatrick for relicense of ported Perl     |
  35  * |   client logic under 2-clause BSD license.                                |
  36  * +---------------------------------------------------------------------------+
  37  *
  38  * @file
  39  * $TCAnet$
  40  */
  41
  42 /**
  43  * This is the PHP client for memcached - a distributed memory cache daemon.
  44  * More information is available at http://www.danga.com/memcached/
  45  *
  46  * Usage example:
  47  *
  48  * require_once 'memcached.php';
  49  *
  50  * $mc = new MWMemcached(array(
  51  *              'servers' => array('127.0.0.1:10000',
  52  *                                 array('192.0.0.1:10010', 2),
  53  *                                 '127.0.0.1:10020'),
  54  *              'debug'   => false,
  55  *              'compress_threshold' => 10240,
  56  *              'persistent' => true));
  57  *
  58  * $mc->add('key', array('some', 'array'));
  59  * $mc->replace('key', 'some random string');
  60  * $val = $mc->get('key');
  61  *
  62  * @author  Ryan T. Dean <rtdean@cytherianage.net>
  63  * @version 0.1.2
  64  */
  65
  66 // {{{ requirements
  67 // }}}
  68
  69 // {{{ class MWMemcached
  70 /**
  71  * memcached client class implemented using (p)fsockopen()
  72  *
  73  * @author  Ryan T. Dean <rtdean@cytherianage.net>
  74  * @ingroup Cache
  75  */
  76 class MWMemcached {
  77         // {{{ properties
  78         // {{{ public
  79
  80         // {{{ constants
  81         // {{{ flags
  82
  83         /**
  84          * Flag: indicates data is serialized
  85          */
  86         const SERIALIZED = 1;
  87
  88         /**
  89          * Flag: indicates data is compressed
  90          */
  91         const COMPRESSED = 2;
  92
  93         // }}}
  94
  95         /**
  96          * Minimum savings to store data compressed
  97          */
  98         const COMPRESSION_SAVINGS = 0.20;
  99
 100         // }}}
 101
 102
 103         /**
 104          * Command statistics
 105          *
 106          * @var     array
 107          * @access  public
 108          */
 109         var $stats;
 110
 111         // }}}
 112         // {{{ private
 113
 114         /**
 115          * Cached Sockets that are connected
 116          *
 117          * @var     array
 118          * @access  private
 119          */
 120         var $_cache_sock;
 121
 122         /**
 123          * Current debug status; 0 - none to 9 - profiling
 124          *
 125          * @var     boolean
 126          * @access  private
 127          */
 128         var $_debug;
 129
 130         /**
 131          * Dead hosts, assoc array, 'host'=>'unixtime when ok to check again'
 132          *
 133          * @var     array
 134          * @access  private
 135          */
 136         var $_host_dead;
 137
 138         /**
 139          * Is compression available?
 140          *
 141          * @var     boolean
 142          * @access  private
 143          */
 144         var $_have_zlib;
 145
 146         /**
 147          * Do we want to use compression?
 148          *
 149          * @var     boolean
 150          * @access  private
 151          */
 152         var $_compress_enable;
 153
 154         /**
 155          * At how many bytes should we compress?
 156          *
 157          * @var     integer
 158          * @access  private
 159          */
 160         var $_compress_threshold;
 161
 162         /**
 163          * Are we using persistent links?
 164          *
 165          * @var     boolean
 166          * @access  private
 167          */
 168         var $_persistent;
 169
 170         /**
 171          * If only using one server; contains ip:port to connect to
 172          *
 173          * @var     string
 174          * @access  private
 175          */
 176         var $_single_sock;
 177
 178         /**
 179          * Array containing ip:port or array(ip:port, weight)
 180          *
 181          * @var     array
 182          * @access  private
 183          */
 184         var $_servers;
 185
 186         /**
 187          * Our bit buckets
 188          *
 189          * @var     array
 190          * @access  private
 191          */
 192         var $_buckets;
 193
 194         /**
 195          * Total # of bit buckets we have
 196          *
 197          * @var     integer
 198          * @access  private
 199          */
 200         var $_bucketcount;
 201
 202         /**
 203          * # of total servers we have
 204          *
 205          * @var     integer
 206          * @access  private
 207          */
 208         var $_active;
 209
 210         /**
 211          * Stream timeout in seconds. Applies for example to fread()
 212          *
 213          * @var     integer
 214          * @access  private
 215          */
 216         var $_timeout_seconds;
 217
 218         /**
 219          * Stream timeout in microseconds
 220          *
 221          * @var     integer
 222          * @access  private
 223          */
 224         var $_timeout_microseconds;
 225
 226         /**
 227          * Connect timeout in seconds
 228          */
 229         var $_connect_timeout;
 230
 231         /**
 232          * Number of connection attempts for each server
 233          */
 234         var $_connect_attempts;
 235
 236         // }}}
 237         // }}}
 238         // {{{ methods
 239         // {{{ public functions
 240         // {{{ memcached()
 241
 242         /**
 243          * Memcache initializer
 244          *
 245          * @param $args Array 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 $key String: key to set with data
 276          * @param $val Mixed: value to store
 277          * @param $exp Integer: (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 Boolean
 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 $key String: key to decrease
 296          * @param $amt Integer: (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 $key String: key to delete
 311          * @param $time Integer: (optional) how long to wait before deleting
 312          *
 313          * @return Boolean: 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 $key
 351          * @param $timeout int
 352          * @return bool
 353          */
 354         public function lock( $key, $timeout = 0 ) {
 355                 /* stub */
 356                 return true;
 357         }
 358
 359         /**
 360          * @param $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 $enable Boolean: 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 $key array|string key to retrieve
 411          * @param $casToken[optional] Float
 412          *
 413          * @return Mixed
 414          */
 415         public function get( $key, &$casToken = null ) {
 416                 wfProfileIn( __METHOD__ );
 417
 418                 if ( $this->_debug ) {
 419                         $this->_debugprint( "get($key)\n" );
 420                 }
 421
 422                 if ( !$this->_active ) {
 423                         wfProfileOut( __METHOD__ );
 424                         return false;
 425                 }
 426
 427                 $sock = $this->get_sock( $key );
 428
 429                 if ( !is_resource( $sock ) ) {
 430                         wfProfileOut( __METHOD__ );
 431                         return false;
 432                 }
 433
 434                 $key = is_array( $key ) ? $key[1] : $key;
 435                 if ( isset( $this->stats['get'] ) ) {
 436                         $this->stats['get']++;
 437                 } else {
 438                         $this->stats['get'] = 1;
 439                 }
 440
 441                 $cmd = "gets $key\r\n";
 442                 if ( !$this->_fwrite( $sock, $cmd ) ) {
 443                         wfProfileOut( __METHOD__ );
 444                         return false;
 445                 }
 446
 447                 $val = array();
 448                 $this->_load_items( $sock, $val, $casToken );
 449
 450                 if ( $this->_debug ) {
 451                         foreach ( $val as $k => $v ) {
 452                                 $this->_debugprint( sprintf( "MemCache: sock %s got %s\n", serialize( $sock ), $k ) );
 453                         }
 454                 }
 455
 456                 $value = false;
 457                 if ( isset( $val[$key] ) ) {
 458                         $value = $val[$key];
 459                 }
 460                 wfProfileOut( __METHOD__ );
 461                 return $value;
 462         }
 463
 464         // }}}
 465         // {{{ get_multi()
 466
 467         /**
 468          * Get multiple keys from the server(s)
 469          *
 470          * @param $keys Array: 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 $key String: key to increment
 535          * @param $amt Integer: (optional) amount to increment
 536          *
 537          * @return Integer: 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 $key String: key to set value as
 552          * @param $value Mixed: value to store
 553          * @param $exp Integer: (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 Boolean
 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 $sock Resource: socket to send command on
 573          * @param $cmd String: 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 $key String: key to set value as
 608          * @param $value Mixed: value to set
 609          * @param $exp Integer: (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 Boolean: 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 $casToken Float: current known value
 629          * @param $key String: key to set value as
 630          * @param $value Mixed: value to set
 631          * @param $exp Integer: (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 Boolean: 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 $thresh Integer: 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 $dbg Boolean: 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 $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 $seconds Integer: number of seconds
 695          * @param $microseconds Integer: 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 $sock String: 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 $sock Integer: socket to connect
 727          * @param $host String: Host:IP to connect to
 728          *
 729          * @return  boolean
 730          * @access  private
 731          */
 732         function _connect_sock( &$sock, $host ) {
 733                 list( $ip, $port ) = explode( ':', $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 $sock String: 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 $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 $key String: key to retrieve value for;
 796          *
 797          * @return Mixed: 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 $key String: key to hash
 845          *
 846          * @return Integer: 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 $cmd String command to perform
 863          * @param $key String|array key to perform it on
 864          * @param $amt Integer amount to adjust
 865          *
 866          * @return Integer: 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 $sock Resource: socket to read from
 904          * @param $ret Array: returned values
 905          * @param $casToken[optional] Float
 906          * @return boolean True for success, false for failure
 907          *
 908          * @access private
 909          */
 910         function _load_items( $sock, &$ret, &$casToken = null ) {
 911                 while ( 1 ) {
 912                         $decl = $this->_fgets( $sock );
 913                         if( $decl === false ) {
 914                                 return false;
 915                         } elseif ( $decl == "END" ) {
 916                                 return true;
 917                         } elseif ( preg_match( '/^VALUE (\S+) (\d+) (\d+) (\d+)$/', $decl, $match ) ) {
 918                                 list( $rkey, $flags, $len, $casToken ) = array( $match[1], $match[2], $match[3], $match[4] );
 919                                 $data = $this->_fread( $sock, $len + 2 );
 920                                 if ( $data === false ) {
 921                                         return false;
 922                                 }
 923                                 if ( substr( $data, -2 ) !== "\r\n" ) {
 924                                         $this->_handle_error( $sock,
 925                                                 'line ending missing from data block from $1' );
 926                                         return false;
 927                                 }
 928                                 $data = substr( $data, 0, -2 );
 929                                 $ret[$rkey] = $data;
 930
 931                                 if ( $this->_have_zlib && $flags & self::COMPRESSED ) {
 932                                         $ret[$rkey] = gzuncompress( $ret[$rkey] );
 933                                 }
 934
 935                                 if ( $flags & self::SERIALIZED ) {
 936                                         $ret[$rkey] = unserialize( $ret[$rkey] );
 937                                 }
 938
 939                         } else {
 940                                 $this->_handle_error( $sock, 'Error parsing response from $1' );
 941                                 return false;
 942                         }
 943                 }
 944         }
 945
 946         // }}}
 947         // {{{ _set()
 948
 949         /**
 950          * Performs the requested storage operation to the memcache server
 951          *
 952          * @param $cmd String: command to perform
 953          * @param $key String: key to act on
 954          * @param $val Mixed: what we need to store
 955          * @param $exp Integer: (optional) Expiration time. This can be a number of seconds
 956          * to cache for (up to 30 days inclusive).  Any timespans of 30 days + 1 second or
 957          * longer must be the timestamp of the time at which the mapping should expire. It
 958          * is safe to use timestamps in all cases, regardless of exipration
 959          * eg: strtotime("+3 hour")
 960          * @param $casToken[optional] Float
 961          *
 962          * @return Boolean
 963          * @access private
 964          */
 965         function _set( $cmd, $key, $val, $exp, $casToken = null ) {
 966                 if ( !$this->_active ) {
 967                         return false;
 968                 }
 969
 970                 $sock = $this->get_sock( $key );
 971                 if ( !is_resource( $sock ) ) {
 972                         return false;
 973                 }
 974
 975                 if ( isset( $this->stats[$cmd] ) ) {
 976                         $this->stats[$cmd]++;
 977                 } else {
 978                         $this->stats[$cmd] = 1;
 979                 }
 980
 981                 $flags = 0;
 982
 983                 if ( !is_scalar( $val ) ) {
 984                         $val = serialize( $val );
 985                         $flags |= self::SERIALIZED;
 986                         if ( $this->_debug ) {
 987                                 $this->_debugprint( sprintf( "client: serializing data as it is not scalar\n" ) );
 988                         }
 989                 }
 990
 991                 $len = strlen( $val );
 992
 993                 if ( $this->_have_zlib && $this->_compress_enable &&
 994                         $this->_compress_threshold && $len >= $this->_compress_threshold )
 995                 {
 996                         $c_val = gzcompress( $val, 9 );
 997                         $c_len = strlen( $c_val );
 998
 999                         if ( $c_len < $len * ( 1 - self::COMPRESSION_SAVINGS ) ) {
1000                                 if ( $this->_debug ) {
1001                                         $this->_debugprint( sprintf( "client: compressing data; was %d bytes is now %d bytes\n", $len, $c_len ) );
1002                                 }
1003                                 $val = $c_val;
1004                                 $len = $c_len;
1005                                 $flags |= self::COMPRESSED;
1006                         }
1007                 }
1008
1009                 $command = "$cmd $key $flags $exp $len";
1010                 if ( $casToken ) {
1011                         $command .= " $casToken";
1012                 }
1013
1014                 if ( !$this->_fwrite( $sock, "$command\r\n$val\r\n" ) ) {
1015                         return false;
1016                 }
1017
1018                 $line = $this->_fgets( $sock );
1019
1020                 if ( $this->_debug ) {
1021                         $this->_debugprint( sprintf( "%s %s (%s)\n", $cmd, $key, $line ) );
1022                 }
1023                 if ( $line == "STORED" ) {
1024                         return true;
1025                 }
1026                 return false;
1027         }
1028
1029         // }}}
1030         // {{{ sock_to_host()
1031
1032         /**
1033          * Returns the socket for the host
1034          *
1035          * @param $host String: Host:IP to get socket for
1036          *
1037          * @return Mixed: IO Stream or false
1038          * @access private
1039          */
1040         function sock_to_host( $host ) {
1041                 if ( isset( $this->_cache_sock[$host] ) ) {
1042                         return $this->_cache_sock[$host];
1043                 }
1044
1045                 $sock = null;
1046                 $now = time();
1047                 list( $ip, /* $port */) = explode( ':', $host );
1048                 if ( isset( $this->_host_dead[$host] ) && $this->_host_dead[$host] > $now ||
1049                         isset( $this->_host_dead[$ip] ) && $this->_host_dead[$ip] > $now
1050                 ) {
1051                         return null;
1052                 }
1053
1054                 if ( !$this->_connect_sock( $sock, $host ) ) {
1055                         return null;
1056                 }
1057
1058                 // Do not buffer writes
1059                 stream_set_write_buffer( $sock, 0 );
1060
1061                 $this->_cache_sock[$host] = $sock;
1062
1063                 return $this->_cache_sock[$host];
1064         }
1065
1066         /**
1067          * @param $text string
1068          */
1069         function _debugprint( $text ) {
1070                 wfDebugLog( 'memcached', $text );
1071         }
1072
1073         /**
1074          * @param $text string
1075          */
1076         function _error_log( $text ) {
1077                 wfDebugLog( 'memcached-serious', "Memcached error: $text" );
1078         }
1079
1080         /**
1081          * Write to a stream. If there is an error, mark the socket dead.
1082          *
1083          * @param $sock The socket
1084          * @param $buf The string to write
1085          * @return bool True on success, false on failure
1086          */
1087         function _fwrite( $sock, $buf ) {
1088                 $bytesWritten = 0;
1089                 $bufSize = strlen( $buf );
1090                 while ( $bytesWritten < $bufSize  ) {
1091                         $result = fwrite( $sock, $buf );
1092                         $data = stream_get_meta_data( $sock );
1093                         if ( $data['timed_out'] ) {
1094                                 $this->_handle_error( $sock, 'timeout writing to $1' );
1095                                 return false;
1096                         }
1097                         // Contrary to the documentation, fwrite() returns zero on error in PHP 5.3.
1098                         if ( $result === false || $result === 0 ) {
1099                                 $this->_handle_error( $sock, 'error writing to $1' );
1100                                 return false;
1101                         }
1102                         $bytesWritten += $result;
1103                 }
1104
1105                 return true;
1106         }
1107
1108         /**
1109          * Handle an I/O error. Mark the socket dead and log an error.
1110          */
1111         function _handle_error( $sock, $msg ) {
1112                 $peer = stream_socket_get_name( $sock, true /** remote **/ );
1113                 if ( strval( $peer ) === '' ) {
1114                         $peer = array_search( $sock, $this->_cache_sock );
1115                         if ( $peer === false ) {
1116                                 $peer = '[unknown host]';
1117                         }
1118                 }
1119                 $msg = str_replace( '$1', $peer, $msg );
1120                 $this->_error_log( "$msg\n" );
1121                 $this->_dead_sock( $sock );
1122         }
1123
1124         /**
1125          * Read the specified number of bytes from a stream. If there is an error,
1126          * mark the socket dead.
1127          *
1128          * @param $sock The socket
1129          * @param $len The number of bytes to read
1130          * @return The string on success, false on failure.
1131          */
1132         function _fread( $sock, $len ) {
1133                 $buf = '';
1134                 while ( $len > 0 ) {
1135                         $result = fread( $sock, $len );
1136                         $data = stream_get_meta_data( $sock );
1137                         if ( $data['timed_out'] ) {
1138                                 $this->_handle_error( $sock, 'timeout reading from $1' );
1139                                 return false;
1140                         }
1141                         if ( $result === false ) {
1142                                 $this->_handle_error( $sock, 'error reading buffer from $1' );
1143                                 return false;
1144                         }
1145                         if ( $result === '' ) {
1146                                 // This will happen if the remote end of the socket is shut down
1147                                 $this->_handle_error( $sock, 'unexpected end of file reading from $1' );
1148                                 return false;
1149                         }
1150                         $len -= strlen( $result );
1151                         $buf .= $result;
1152                 }
1153                 return $buf;
1154         }
1155
1156         /**
1157          * Read a line from a stream. If there is an error, mark the socket dead.
1158          * The \r\n line ending is stripped from the response.
1159          *
1160          * @param $sock The socket
1161          * @return The string on success, false on failure
1162          */
1163         function _fgets( $sock ) {
1164                 $result = fgets( $sock );
1165                 // fgets() may return a partial line if there is a select timeout after
1166                 // a successful recv(), so we have to check for a timeout even if we
1167                 // got a string response.
1168                 $data = stream_get_meta_data( $sock );
1169                 if ( $data['timed_out'] ) {
1170                         $this->_handle_error( $sock, 'timeout reading line from $1' );
1171                         return false;
1172                 }
1173                 if ( $result === false ) {
1174                         $this->_handle_error( $sock, 'error reading line from $1' );
1175                         return false;
1176                 }
1177                 if ( substr( $result, -2 ) === "\r\n" ) {
1178                         $result = substr( $result, 0, -2 );
1179                 } elseif ( substr( $result, -1 ) === "\n" ) {
1180                         $result = substr( $result, 0, -1 );
1181                 } else {
1182                         $this->_handle_error( $sock, 'line ending missing in response from $1' );
1183                         return false;
1184                 }
1185                 return $result;
1186         }
1187
1188         /**
1189          * Flush the read buffer of a stream
1190          * @param $f Resource
1191          */
1192         function _flush_read_buffer( $f ) {
1193                 if ( !is_resource( $f ) ) {
1194                         return;
1195                 }
1196                 $r = array( $f );
1197                 $w = null;
1198                 $e = null;
1199                 $n = stream_select( $r, $w, $e, 0, 0 );
1200                 while ( $n == 1 && !feof( $f ) ) {
1201                         fread( $f, 1024 );
1202                         $r = array( $f );
1203                         $w = null;
1204                         $e = null;
1205                         $n = stream_select( $r, $w, $e, 0, 0 );
1206                 }
1207         }
1208
1209         // }}}
1210         // }}}
1211         // }}}
1212 }
1213
1214
1215 // }}}
1216
1217 class MemCachedClientforWiki extends MWMemcached {
1218 }