原贴：http://blog.csdn.net/heiyeshuwu/archive/2006/07/07/890078.aspx memcached的php客户端操作类一 ?php // //+---------------------------------------------------------------------------+ //|memcachedclient,php| //+---------------------------
原贴：http://blog.csdn.net/heiyeshuwu/archive/2006/07/07/890078.aspx
memcached的php客户端操作类一
 array('127.0.0.1:10000', 
 *                                 array('192.0.0.1:10010', 2),
 *                                 '127.0.0.1:10020'),
 *              'debug'   => false,
 *              'compress_threshold' => 10240,
 *              'persistant' => true));
 *
 * $mc->add('key', array('some', 'array'));
 * $mc->replace('key', 'some random string');
 * $val = $mc->get('key');
 *
 * @author  ryan t. dean 
 * @package memcached-client
 * @version 0.1.2
 */
// {{{ requirements
// }}}
// {{{ constants
// {{{ flags
/**
 * flag: indicates data is serialized
 */
define(memcache_serialized, 10);
/**
 * flag: indicates data is compressed
 */
define(memcache_compressed, 11);
// }}}
/**
 * minimum savings to store data compressed
 */
define(compression_savings, 0.20);
// }}}
// {{{ class memcached
/**
 * memcached client class implemented using (p)fsockopen()
 *
 * @author  ryan t. dean 
 * @package memcached-client
 */
class memcached
{
   // {{{ properties
   // {{{ public
/**
    * command statistics
    *
    * @var     array
    * @access  public
    */
   var $stats;
// }}}
   // {{{ private
/**
    * cached sockets that are connected
    *
    * @var     array
    * @access  private
    */
   var $_cache_sock;
/**
    * current debug status; 0 - none to 9 - profiling
    *
    * @var     boolean
    * @access  private
    */
   var $_debug;
/**
    * dead hosts, assoc array, 'host'=>'unixtime when ok to check again'
    *
    * @var     array
    * @access  private
    */
   var $_host_dead;
/**
    * is compression available?
    *
    * @var     boolean
    * @access  private
    */
   var $_have_zlib;
/**
    * do we want to use compression?
    *
    * @var     boolean
    * @access  private
    */
   var $_compress_enable;
/**
    * at how many bytes should we compress?
    *
    * @var     interger
    * @access  private
    */
   var $_compress_threshold;
/**
    * are we using persistant links?
    *
    * @var     boolean
    * @access  private
    */
   var $_persistant;
/**
    * if only using one server; contains ip:port to connect to
    *
    * @var     string
    * @access  private
    */
   var $_single_sock;
/**
    * array containing ip:port or array(ip:port, weight)
    *
    * @var     array
    * @access  private
    */
   var $_servers;
/**
    * our bit buckets
    *
    * @var     array
    * @access  private
    */
   var $_buckets;
/**
    * total # of bit buckets we have
    *
    * @var     interger
    * @access  private
    */
   var $_bucketcount;
/**
    * # of total servers we have
    *
    * @var     interger
    * @access  private
    */
   var $_active;
// }}}
   // }}}
   // {{{ methods
   // {{{ public functions
   // {{{ memcached()
/**
    * memcache initializer
    *
    * @param   array    $args    associative array of settings
    *
    * @return  mixed
    * @access  public
    */
   function memcached ($args)
   {
      $this->set_servers($args['servers']);
      $this->_debug = $args['debug'];
      $this->stats = array();
      $this->_compress_threshold = $args['compress_threshold'];
      $this->_persistant = isset($args['persistant']) ? $args['persistant'] : false;
      $this->_compress_enable = true;
      $this->_have_zlib = function_exists(gzcompress);
$this->_cache_sock = array();
      $this->_host_dead = array();
   }
// }}}
   // {{{ add()
/**
    * adds a key/value to the memcache server if one isn't already set with 
    * that key
    *
    * @param   string   $key     key to set with data
    * @param   mixed    $val     value to store
    * @param   interger $exp     (optional) time to expire data at
    *
    * @return  boolean
    * @access  public
    */
   function add ($key, $val, $exp = 0)
   {
      return $this->_set('add', $key, $val, $exp);
   }
// }}}
   // {{{ decr()
/**
    * decriment a value stored on the memcache server
    *
    * @param   string   $key     key to decriment
    * @param   interger $amt     (optional) amount to decriment
    *
    * @return  mixed    false on failure, value on success
    * @access  public
    */
   function decr ($key, $amt=1)
   {
      return $this->_incrdecr('decr', $key, $amt);
   }
// }}}
   // {{{ delete()
/**
    * deletes a key from the server, optionally after $time
    *
    * @param   string   $key     key to delete
    * @param   interger $time    (optional) how long to wait before deleting
    *
    * @return  boolean  true on success, false on failure
    * @access  public
    */
   function delete ($key, $time = 0)
   {
      if (!$this->_active)
         return false;
$sock = $this->get_sock($key);
      if (!is_resource($sock))
         return false;
$key = is_array($key) ? $key[1] : $key;
$this->stats['delete']++;
      $cmd = delete $key $time/r/n;
      if(!fwrite($sock, $cmd, strlen($cmd)))
      {
         $this->_dead_sock($sock);
         return false;
      }
      $res = trim(fgets($sock));
if ($this->_debug)
         printf(memcache: delete %s (%s)/n, $key, $res);
if ($res == deleted)
         return true;
      return false;
   }
// }}}
   // {{{ disconnect_all()
/**
    * disconnects all connected sockets
    *
    * @access  public
    */
   function disconnect_all ()
   {
      foreach ($this->_cache_sock as $sock)
         fclose($sock);
$this->_cache_sock = array();
   }
// }}}
   // {{{ enable_compress()
/**
    * enable / disable compression
    *
    * @param   boolean  $enable  true to enable, false to disable
    *
    * @access  public
    */
   function enable_compress ($enable)
   {
      $this->_compress_enable = $enable;
   }
// }}}
   // {{{ forget_dead_hosts()
/**
    * forget about all of the dead hosts
    *
    * @access  public
    */
   function forget_dead_hosts ()
   {
      $this->_host_dead = array();
   }
// }}}
   // {{{ get()
/**
    * retrieves the value associated with the key from the memcache server
    *
    * @param  string   $key     key to retrieve
    *
    * @return  mixed
    * @access  public
    */
   function get ($key)
   {
      if (!$this->_active)
         return false;
$sock = $this->get_sock($key);
if (!is_resource($sock))
         return false;
$this->stats['get']++;
$cmd = get $key/r/n;
      if (!fwrite($sock, $cmd, strlen($cmd)))
      {
         $this->_dead_sock($sock);
         return false;
      }
$val = array();
      $this->_load_items($sock, $val);
if ($this->_debug)
         foreach ($val as $k => $v)
            printf(memcache: sock %s got %s => %s/r/n, $sock, $k, $v);
return $val[$key];
   }
// }}}
   // {{{ get_multi()
/**
    * get multiple keys from the server(s)
    *
    * @param   array    $keys    keys to retrieve
    *
    * @return  array
    * @access  public
    */
   function get_multi ($keys)
   {
      if (!$this->_active)
         return false;
$this->stats['get_multi']++;
foreach ($keys as $key)
      {
         $sock = $this->get_sock($key);
         if (!is_resource($sock)) continue;
         $key = is_array($key) ? $key[1] : $key;
         if (!isset($sock_keys[$sock]))
         {
            $sock_keys[$sock] = array();
            $socks[] = $sock;
         }
         $sock_keys[$sock][] = $key;
      }
// send out the requests
      foreach ($socks as $sock)
      {
         $cmd = get;
         foreach ($sock_keys[$sock] as $key)
         {
            $cmd .=  . $key;
         }
         $cmd .= /r/n;
if (fwrite($sock, $cmd, strlen($cmd)))
         {
            $gather[] = $sock;
         } else
         {
            $this->_dead_sock($sock);
         }
      }
// parse responses
      $val = array();
      foreach ($gather as $sock)
      {
         $this->_load_items($sock, $val);
      }
if ($this->_debug)
         foreach ($val as $k => $v)
            printf(memcache: got %s => %s/r/n, $k, $v);
return $val;
   }
// }}}
   // {{{ incr()
/**
    * increments $key (optionally) by $amt
    *
    * @param   string   $key     key to increment
    * @param   interger $amt     (optional) amount to increment
    *
    * @return  interger new key value?
    * @access  public
    */
   function incr ($key, $amt=1)
   {
      return $this->_incrdecr('incr', $key, $amt);
   }
// }}}
   // {{{ replace()
/**
    * overwrites an existing value for key; only works if key is already set
    *
    * @param   string   $key     key to set value as
    * @param   mixed    $value   value to store
    * @param   interger $exp     (optional) experiation time
    *
    * @return  boolean
    * @access  public
    */
   function replace ($key, $value, $exp=0)
   {
      return $this->_set('replace', $key, $value, $exp);
   }
// }}}
   // {{{ run_command()
/**
    * passes through $cmd to the memcache server connected by $sock; returns 
    * output as an array (null array if no output)
    *
    * note: due to a possible bug in how php reads while using fgets(), each
    *       line may not be terminated by a /r/n.  more specifically, my testing
    *       has shown that, on freebsd at least, each line is terminated only
    *       with a /n.  this is with the php flag auto_detect_line_endings set
    *       to falase (the default).
    *
    * @param   resource $sock    socket to send command on
    * @param   string   $cmd     command to run
    *
    * @return  array    output array
    * @access  public
    */
   function run_command ($sock, $cmd)
   {
      if (!is_resource($sock))
         return array();
if (!fwrite($sock, $cmd, strlen($cmd)))
         return array();
while (true)
      {
         $res = fgets($sock);
         $ret[] = $res;
         if (preg_match('/^end/', $res))
            break;
         if (strlen($res) == 0)
            break;
      }
      return $ret;
   }
// }}}
   // {{{ set()
/**
    * unconditionally sets a key to a given value in the memcache.  returns true
    * if set successfully.
    *
    * @param   string   $key     key to set value as
    * @param   mixed    $value   value to set
    * @param   interger $exp     (optional) experiation time
    *
    * @return  boolean  true on success
    * @access  public
    */
   function set ($key, $value, $exp=0)
   {
      return $this->_set('set', $key, $value, $exp);
   }
// }}}
   // {{{ set_compress_threshold()
/**
    * sets the compression threshold
    *
    * @param   interger $thresh  threshold to compress if larger than
    *
    * @access  public
    */
   function set_compress_threshold ($thresh)
   {
      $this->_compress_threshold = $thresh;
   }
// }}}
   // {{{ set_debug()
/**
    * sets the debug flag
    *
    * @param   boolean  $dbg     true for debugging, false otherwise
    *
    * @access  public
    *
    * @see     memcahced::memcached
    */
   function set_debug ($dbg)
   {
      $this->_debug = $dbg;
   }
// }}}
   // {{{ set_servers()
/**
    * sets the server list to distribute key gets and puts between
    *
    * @param   array    $list    array of servers to connect to
    *
    * @access  public
    *
    * @see     memcached::memcached()
    */
   function set_servers ($list)
   {
      $this->_servers = $list;
      $this->_active = count($list);
      $this->_buckets = null;
      $this->_bucketcount = 0;
$this->_single_sock = null;
      if ($this->_active == 1)
         $this->_single_sock = $this->_servers[0];
   }
// }}}
   // }}}
   // {{{ private methods
   // {{{ _close_sock()
/**
    * close the specified socket
    *
    * @param   string   $sock    socket to close
    *
    * @access  private
    */
   function _close_sock ($sock)
   {
      $host = array_search($sock, $this->_cache_sock);
      fclose($this->_cache_sock[$host]);
      unset($this->_cache_sock[$host]);
   }
// }}}
   // {{{ _connect_sock()
/**
    * connects $sock to $host, timing out after $timeout
    *
    * @param   interger $sock    socket to connect
    * @param   string   $host    host:ip to connect to
    * @param   float    $timeout (optional) timeout value, defaults to 0.25s
    *
    * @return  boolean
    * @access  private
    */
   function _connect_sock (&$sock, $host, $timeout = 0.25)
   {
      list ($ip, $port) = explode(:, $host);
      if ($this->_persistant == 1)
      {
         $sock = @pfsockopen($ip, $port, $errno, $errstr, $timeout);
      } else
      {
         $sock = @fsockopen($ip, $port, $errno, $errstr, $timeout);
      }
if (!$sock)
         return false;
      return true;
   }
// }}}
   // {{{ _dead_sock()
/**
    * marks a host as dead until 30-40 seconds in the future
    *
    * @param   string   $sock    socket to mark as dead
    *
    * @access  private
    */
   function _dead_sock ($sock)
   {
      $host = array_search($sock, $this->_cache_sock);
      list ($ip, $port) = explode(:, $host);
      $this->_host_dead[$ip] = time() + 30 + intval(rand(0, 10));
      $this->_host_dead[$host] = $this->_host_dead[$ip];
      unset($this->_cache_sock[$host]);
   }
// }}}
   // {{{ get_sock()
/**
    * get_sock
    *
    * @param   string   $key     key to retrieve value for;
    *
    * @return  mixed    resource on success, false on failure
    * @access  private
    */
   function get_sock ($key)
   {
      if (!$this->_active)
         return false;
if ($this->_single_sock !== null