[pLog-svn] r4038 - in plog/trunk: class/cache class/cache/Memcached_Client config

oscar at devel.lifetype.net oscar at devel.lifetype.net
Sun Sep 24 15:17:20 GMT 2006


Author: oscar
Date: 2006-09-24 15:17:20 +0000 (Sun, 24 Sep 2006)
New Revision: 4038

Added:
   plog/trunk/class/cache/Memcached_Client/
   plog/trunk/class/cache/Memcached_Client/memcached-client.php
   plog/trunk/class/cache/memcache.class.php
Modified:
   plog/trunk/class/cache/cache.class.php
   plog/trunk/class/cache/cachemanager.class.php
   plog/trunk/config/config.properties.php
Log:
Merged Mark's patch to support memcached. I really have no way to test it, so hopefully you Mark will be able to confirm that it works. I've moved the cache settings to their own file (cache.properties.php) since I think that we should keep config.properties.php for database settings and move more specific stuff to their own files.


Added: plog/trunk/class/cache/Memcached_Client/memcached-client.php
===================================================================
--- plog/trunk/class/cache/Memcached_Client/memcached-client.php	2006-09-24 12:13:51 UTC (rev 4037)
+++ plog/trunk/class/cache/Memcached_Client/memcached-client.php	2006-09-24 15:17:20 UTC (rev 4038)
@@ -0,0 +1,1078 @@
+<?php
+//
+// +---------------------------------------------------------------------------+
+// | memcached client, PHP                                                     |
+// +---------------------------------------------------------------------------+
+// | Copyright (c) 2003 Ryan T. Dean <rtdean at cytherianage.net>                 |
+// | All rights reserved.                                                      |
+// |                                                                           |
+// | Redistribution and use in source and binary forms, with or without        |
+// | modification, are permitted provided that the following conditions        |
+// | are met:                                                                  |
+// |                                                                           |
+// | 1. Redistributions of source code must retain the above copyright         |
+// |    notice, this list of conditions and the following disclaimer.          |
+// | 2. Redistributions in binary form must reproduce the above copyright      |
+// |    notice, this list of conditions and the following disclaimer in the    |
+// |    documentation and/or other materials provided with the distribution.   |
+// |                                                                           |
+// | THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR      |
+// | IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
+// | OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.   |
+// | IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,          |
+// | INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT  |
+// | NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
+// | DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY     |
+// | THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT       |
+// | (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF  |
+// | THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.         |
+// +---------------------------------------------------------------------------+
+// | Author: Ryan T. Dean <rtdean at cytherianage.net>                            |
+// | Heavily influenced by the Perl memcached client by Brad Fitzpatrick.      |
+// |   Permission granted by Brad Fitzpatrick for relicense of ported Perl     |
+// |   client logic under 2-clause BSD license.                                |
+// +---------------------------------------------------------------------------+
+//
+// $TCAnet$
+//
+
+/**
+ * This is the PHP client for memcached - a distributed memory cache daemon.
+ * More information is available at http://www.danga.com/memcached/
+ *
+ * Usage example:
+ *
+ * require_once 'memcached.php';
+ *
+ * $mc = new memcached(array(
+ *              'servers' => 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 <rtdean at cytherianage.net>
+ * @package memcached-client
+ * @version 0.1.2
+ */
+
+// {{{ requirements
+// }}}
+
+// {{{ constants
+// {{{ flags
+
+/**
+ * Flag: indicates data is serialized
+ */
+define("MEMCACHE_SERIALIZED", 1<<0);
+
+/**
+ * Flag: indicates data is compressed
+ */
+define("MEMCACHE_COMPRESSED", 1<<1);
+
+// }}}
+
+/**
+ * Minimum savings to store data compressed
+ */
+define("COMPRESSION_SAVINGS", 0.20);
+
+// }}}
+
+// {{{ class memcached
+/**
+ * memcached client class implemented using (p)fsockopen()
+ *
+ * @author  Ryan T. Dean <rtdean at cytherianage.net>
+ * @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;
+
+   /**
+    * Stream timeout in seconds. Applies for example to fread()
+    *
+    * @var     integer
+    * @access  private
+    */
+   var $_timeout_seconds;
+
+   /**
+    * Stream timeout in microseconds
+    *
+    * @var     integer
+    * @access  private
+    */
+   var $_timeout_microseconds;
+
+   // }}}
+   // }}}
+   // {{{ 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 = array_key_exists('persistant', $args) ? (@$args['persistant']) : false;
+      $this->_compress_enable = true;
+      $this->_have_zlib = function_exists("gzcompress");
+
+      $this->_cache_sock = array();
+      $this->_host_dead = array();
+
+      $this->_timeout_seconds = 1;
+      $this->_timeout_microseconds = 0;
+   }
+
+   // }}}
+   // {{{ 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(!$this->_safe_fwrite($sock, $cmd, strlen($cmd)))
+      {
+         $this->_dead_sock($sock);
+         return false;
+      }
+      $res = trim(fgets($sock));
+
+      if ($this->_debug)
+         $this->_debugprint(sprintf("MemCache: delete %s (%s)\n", $key, $res));
+
+      if ($res == "DELETED")
+         return true;
+      return false;
+   }
+   
+   // }}}
+   // {{{ flush_all()
+
+   /**
+    * Flush all keys from the server
+	*
+    * @return  boolean  Always TRUE
+    * @access  public
+    */
+   function flush_all ()
+   {
+      if (!$this->_active)
+         return false;
+
+      foreach ($this->_servers as $server)
+      {
+         if (is_array($server))
+         {
+            for ($i=0; $i<$server[1]; $i++)
+               $hosts[] = $server[0];
+         } else
+         {
+            $hosts[] = $server;
+         }
+      }
+      
+      foreach ($hosts as $host)
+      {  
+         $sock = $this->sock_to_host($host);
+         if (is_resource($sock)) {
+            $this->_flush_read_buffer($sock);
+      
+            @$this->stats['flush_all']++;
+            $cmd = "flush_all\r\n";
+            if(!$this->_safe_fwrite($sock, $cmd, strlen($cmd)))
+            {
+               $this->_dead_sock($sock);
+               continue;
+            }
+            $res = trim(fgets($sock));
+
+            if ($this->_debug)
+               $this->_debugprint(sprintf("MemCache: flush_all %s (%s)\n", $host, $res));
+         }
+      }
+      return true;
+   }
+
+   // }}}
+   // {{{ 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 (!$this->_safe_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)
+            $this->_debugprint(@sprintf("MemCache: sock %s got %s => %s\r\n", serialize($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 ($this->_safe_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)
+            $this->_debugprint(sprintf("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 (!$this->_safe_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];
+   }
+
+   /**
+    * Sets the timeout for new connections
+    *
+    * @param   integer  $seconds Number of seconds
+    * @param   integer  $microseconds  Number of microseconds
+    *
+    * @access  public
+    */
+   function set_timeout ($seconds, $microseconds)
+   {
+      $this->_timeout_seconds = $seconds;
+      $this->_timeout_microseconds = $microseconds;
+   }
+
+   // }}}
+   // }}}
+   // {{{ 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) {
+         if ($this->_debug)
+            $this->_debugprint( "Error connecting to $host: $errstr\n" );
+         return false;
+      }
+
+      // Initialise timeout
+      stream_set_timeout($sock, $this->_timeout_seconds, $this->_timeout_microseconds);
+
+      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) {
+         $this->_flush_read_buffer($this->_single_sock);
+         return $this->sock_to_host($this->_single_sock);
+      }
+
+      $hv = is_array($key) ? intval($key[0]) : $this->_hashfunc($key);
+
+      if ($this->_buckets === null)
+      {
+         foreach ($this->_servers as $v)
+         {
+            if (is_array($v))
+            {
+               for ($i=0; $i<$v[1]; $i++)
+                  $bu[] = $v[0];
+            } else
+            {
+               $bu[] = $v;
+            }
+         }
+         $this->_buckets = $bu;
+         $this->_bucketcount = count($bu);
+      }
+
+      $realkey = is_array($key) ? $key[1] : $key;
+      for ($tries = 0; $tries<20; $tries++)
+      {
+         $host = $this->_buckets[$hv % $this->_bucketcount];
+         $sock = $this->sock_to_host($host);
+         if (is_resource($sock)) {
+            $this->_flush_read_buffer($sock);
+            return $sock;
+         }
+         $hv += $this->_hashfunc($tries . $realkey);
+      }
+
+      return false;
+   }
+
+   // }}}
+   // {{{ _hashfunc()
+
+   /**
+    * Creates a hash interger based on the $key
+    *
+    * @param   string   $key     Key to hash
+    *
+    * @return  interger Hash value
+    * @access  private
+    */
+   function _hashfunc ($key)
+   {
+      # Hash function must on [0,0x7ffffff]
+      # We take the first 31 bits of the MD5 hash, which unlike the hash
+      # function used in a previous version of this client, works
+      return hexdec(substr(md5($key),0,8)) & 0x7fffffff;
+   }
+
+   // }}}
+   // {{{ _incrdecr()
+
+   /**
+    * Perform increment/decriment on $key
+    *
+    * @param   string   $cmd     Command to perform
+    * @param   string   $key     Key to perform it on
+    * @param   interger $amt     Amount to adjust
+    *
+    * @return  interger    New value of $key
+    * @access  private
+    */
+   function _incrdecr ($cmd, $key, $amt=1)
+   {
+      if (!$this->_active)
+         return null;
+
+      $sock = $this->get_sock($key);
+      if (!is_resource($sock))
+         return null;
+
+      $key = is_array($key) ? $key[1] : $key;
+      @$this->stats[$cmd]++;
+      if (!$this->_safe_fwrite($sock, "$cmd $key $amt\r\n"))
+         return $this->_dead_sock($sock);
+
+      stream_set_timeout($sock, 1, 0);
+      $line = fgets($sock);
+      if (!preg_match('/^(\d+)/', $line, $match))
+         return null;
+      return $match[1];
+   }
+
+   // }}}
+   // {{{ _load_items()
+
+   /**
+    * Load items into $ret from $sock
+    *
+    * @param   resource $sock    Socket to read from
+    * @param   array    $ret     Returned values
+    *
+    * @access  private
+    */
+   function _load_items ($sock, &$ret)
+   {
+      while (1)
+      {
+         $decl = fgets($sock);
+         if ($decl == "END\r\n")
+         {
+            return true;
+         } elseif (preg_match('/^VALUE (\S+) (\d+) (\d+)\r\n$/', $decl, $match))
+         {
+            list($rkey, $flags, $len) = array($match[1], $match[2], $match[3]);
+            $bneed = $len+2;
+            $offset = 0;
+
+            while ($bneed > 0)
+            {
+               $data = fread($sock, $bneed);
+               $n = strlen($data);
+               if ($n == 0)
+                  break;
+               $offset += $n;
+               $bneed -= $n;
+               @$ret[$rkey] .= $data;
+            }
+
+            if ($offset != $len+2)
+            {
+               // Something is borked!
+               if ($this->_debug)
+                  $this->_debugprint(sprintf("Something is borked!  key %s expecting %d got %d length\n", $rkey, $len+2, $offset));
+
+               unset($ret[$rkey]);
+               $this->_close_sock($sock);
+               return false;
+            }
+
+            if ($this->_have_zlib && $flags & MEMCACHE_COMPRESSED)
+               $ret[$rkey] = gzuncompress($ret[$rkey]);
+
+            $ret[$rkey] = rtrim($ret[$rkey]);
+
+            if ($flags & MEMCACHE_SERIALIZED)
+               $ret[$rkey] = unserialize($ret[$rkey]);
+
+         } else
+         {
+            $this->_debugprint("Error parsing memcached response\n");
+            return 0;
+         }
+      }
+   }
+
+   // }}}
+   // {{{ _set()
+
+   /**
+    * Performs the requested storage operation to the memcache server
+    *
+    * @param   string   $cmd     Command to perform
+    * @param   string   $key     Key to act on
+    * @param   mixed    $val     What we need to store
+    * @param   interger $exp     When it should expire
+    *
+    * @return  boolean
+    * @access  private
+    */
+   function _set ($cmd, $key, $val, $exp)
+   {
+      if (!$this->_active)
+         return false;
+
+      $sock = $this->get_sock($key);
+      if (!is_resource($sock))
+         return false;
+
+      @$this->stats[$cmd]++;
+
+      $flags = 0;
+
+      if (!is_scalar($val))
+      {
+         $val = serialize($val);
+         $flags |= MEMCACHE_SERIALIZED;
+         if ($this->_debug)
+            $this->_debugprint(sprintf("client: serializing data as it is not scalar\n"));
+      }
+
+      $len = strlen($val);
+
+      if ($this->_have_zlib && $this->_compress_enable &&
+          $this->_compress_threshold && $len >= $this->_compress_threshold)
+      {
+         $c_val = gzcompress($val, 9);
+         $c_len = strlen($c_val);
+
+         if ($c_len < $len*(1 - COMPRESSION_SAVINGS))
+         {
+            if ($this->_debug)
+               $this->_debugprint(sprintf("client: compressing data; was %d bytes is now %d bytes\n", $len, $c_len));
+            $val = $c_val;
+            $len = $c_len;
+            $flags |= MEMCACHE_COMPRESSED;
+         }
+      }
+      if (!$this->_safe_fwrite($sock, "$cmd $key $flags $exp $len\r\n$val\r\n"))
+         return $this->_dead_sock($sock);
+
+      $line = trim(fgets($sock));
+
+      if ($this->_debug)
+      {
+         if ($flags & MEMCACHE_COMPRESSED)
+            $val = 'compressed data';
+         $this->_debugprint(sprintf("MemCache: %s %s => %s (%s)\n", $cmd, $key, $val, $line));
+      }
+      if ($line == "STORED")
+         return true;
+      return false;
+   }
+
+   // }}}
+   // {{{ sock_to_host()
+
+   /**
+    * Returns the socket for the host
+    *
+    * @param   string   $host    Host:IP to get socket for
+    *
+    * @return  mixed    IO Stream or false
+    * @access  private
+    */
+   function sock_to_host ($host)
+   {
+      if (isset($this->_cache_sock[$host]))
+         return $this->_cache_sock[$host];
+
+      $now = time();
+      list ($ip, $port) = explode (":", $host);
+      if (isset($this->_host_dead[$host]) && $this->_host_dead[$host] > $now ||
+          isset($this->_host_dead[$ip]) && $this->_host_dead[$ip] > $now)
+         return null;
+
+      if (!$this->_connect_sock($sock, $host))
+         return $this->_dead_sock($host);
+
+      // Do not buffer writes
+      stream_set_write_buffer($sock, 0);
+
+      $this->_cache_sock[$host] = $sock;
+
+      return $this->_cache_sock[$host];
+   }
+
+   function _debugprint($str){
+      print($str);
+   }
+
+   /**
+    * Write to a stream, timing out after the correct amount of time
+    *
+    * @return bool false on failure, true on success
+    */
+   function _safe_fwrite($f, $buf, $len = false) {
+      if ($len === false) {
+         $bytesWritten = @fwrite($f, $buf);
+      } else {
+         $bytesWritten = @fwrite($f, $buf, $len);
+      }
+      return $bytesWritten;
+   }
+
+   /**
+    * Flush the read buffer of a stream
+    */
+   function _flush_read_buffer($f) {
+      if (!is_resource($f)) {
+         return;
+      }
+      $n = stream_select($r=array($f), $w = NULL, $e = NULL, 0, 0);
+      while ($n == 1 && !feof($f)) {
+         fread($f, 1024);
+         $n = stream_select($r=array($f), $w = NULL, $e = NULL, 0, 0);
+      }
+   }
+
+   // }}}
+   // }}}
+   // }}}
+}
+
+// vim: sts=3 sw=3 et
+
+// }}}
+?>


Property changes on: plog/trunk/class/cache/Memcached_Client/memcached-client.php
___________________________________________________________________
Name: svn:executable
   + *

Modified: plog/trunk/class/cache/cache.class.php
===================================================================
--- plog/trunk/class/cache/cache.class.php	2006-09-24 12:13:51 UTC (rev 4037)
+++ plog/trunk/class/cache/cache.class.php	2006-09-24 15:17:20 UTC (rev 4038)
@@ -31,6 +31,8 @@
 
         var $_disabledCacheCategories = array();
 
+        var $lifeTime;
+
 		/** 
 	     * Constructor of the class. 
 	     *
@@ -41,8 +43,20 @@
             require_once( PLOG_CLASS_PATH . "class/cache/Cache_Lite/Lite.php" );
             
             $this->cache = new Cache_Lite( $cacheProperties );
+
+            $this->lifeTime = $cacheProperties['lifeTime'];
         }
 
+		/** 
+		 * Sets the lifetime of cached data
+		 *
+		 * @param lifeType
+		 */
+		function setLifeTime( $lifeTime )
+		{
+			$this->lifeTime = $lifeTime;
+		}		
+
 		/**
 		 * Saves data to the cache. Data is identified by an id and a group. Any data
 		 * can be saved to the cache but please check that you are using unique keys for
@@ -57,6 +71,7 @@
         function setData( $id, $group, $data )
         {
             if( $this->_cacheCategoryEnabled($group) ) {
+                $this->cache->setLifeTime( $this->lifeTime );	
                 return $this->cache->save( $data, $id, "$group" );
             } else
                 return true;

Modified: plog/trunk/class/cache/cachemanager.class.php
===================================================================
--- plog/trunk/class/cache/cachemanager.class.php	2006-09-24 12:13:51 UTC (rev 4037)
+++ plog/trunk/class/cache/cachemanager.class.php	2006-09-24 15:17:20 UTC (rev 4038)
@@ -18,7 +18,7 @@
 		 *
 		 * @param cacheEnabled Set this to false if you wish this class to always return no data,
 		 * meaning that it will have to be loaded every time.
-		 * @return The current global instance of the Cache class
+		 * @return The current global instance of the Lite class
 		 */
         function &getCache( $cacheEnabled = true )
         {
@@ -26,21 +26,39 @@
 
             if( $cache == null ) {
                 // source the neccessary files
-                require_once( PLOG_CLASS_PATH . "class/cache/cache.class.php" );
-                require_once( PLOG_CLASS_PATH . "class/config/config.class.php" );
+                require_once( PLOG_CLASS_PATH . "class/config/configfilestorage.class.php" );
 
-                // define defaults
-                $cacheParameter = array(
-                    'cacheDir' => "./tmp/",
-                    'lifeTime' => 604800,
-                    'readControl' => false,
-                    'automaticSerialization' => true,
-                    'hashedDirectoryLevel' => 2,
-					'caching' => $cacheEnabled
-                );
+				$config = new ConfigFileStorage( Array( "file" => PLOG_CLASS_PATH."config/cache.properties.php" ));
+				
+				if( $config->getValue( 'cache_method' ) == 'memcached' ) {
+					require_once( PLOG_CLASS_PATH . "class/cache/memcache.class.php" );
+					// define defaults
+					$cacheParameter = array(
+						'servers' => $config->getValue( 'memcached_servers' ),
+						'life_time' => $config->getValue( 'memcached_life_time' ),
+						'debug' => $config->getValue( 'memcached_debug' ),
+						'compress_threshold' => $config->getValue( 'memcached_compress_threshold' ),
+						'persistant' => $config->getValue( 'memcached_persistant' ),
+					);
+					
+					// build a new cache object
+					$cache =& new MemCache( $cacheParameter);
+				}
+				else {					
+                	require_once( PLOG_CLASS_PATH . "class/cache/cache.class.php" );					
+	                // configure the Cache_Lite parameters, but providing some defaults in case the config file isn't there
+	                $cacheParameter = array(
+						'cacheDir' => $config->getValue( 'cache_lite_cache_dir', "./tmp/" ),
+						'lifeTime' => $config->getValue( 'cache_lite_life_time', 604800 ),
+						'readControl' => $config->getValue( 'cache_lite_read_control', false ),
+						'automaticSerialization' => $config->getValue( 'cache_lite_automatic_serialization', true ),
+						'hashedDirectoryLevel' => $config->getValue( 'cache_lite_hashed_directory_level', 2 ),
+						'caching' => $cacheEnabled
+	                );
 
-                // build a new cache object
-                $cache =& new Cache( $cacheParameter);
+	                // build a new cache object
+	                $cache =& new Cache( $cacheParameter);
+				}
             }
             return $cache;
         }

Added: plog/trunk/class/cache/memcache.class.php
===================================================================
--- plog/trunk/class/cache/memcache.class.php	2006-09-24 12:13:51 UTC (rev 4037)
+++ plog/trunk/class/cache/memcache.class.php	2006-09-24 15:17:20 UTC (rev 4038)
@@ -0,0 +1,162 @@
+<?php
+
+	include_once( PLOG_CLASS_PATH . "class/object/loggable.class.php" );
+
+	$__memcache_hits = 0;
+	$__memcache_misses = 0;
+	$__memcache_queries = 0;
+
+	/**
+	 * \ingroup Cache
+	 *
+	 * Support for caching via memcached
+	 */
+    class MemCache extends Loggable
+    {
+        var $cache;
+        var $lifeTime;
+
+        var $_disabledCacheCategories = array();
+
+        function MemCache( $cacheProperties )
+        {
+            require_once( PLOG_CLASS_PATH . "class/cache/Memcached_Client/memcached-client.php" );
+			$this->Loggable();
+            
+            $this->cache = new memcached( $cacheProperties );
+            $this->lifeTime = $cacheProperties['life_time'];
+        }
+
+		function setLifeTime( $lifeTime )
+		{
+			$this->lifeTime = $lifeTime;
+		}
+
+        function setData( $id, $group, $data )
+        {
+            if( $this->_cacheCategoryEnabled($group) ) {
+                $this->log->debug("Caching $id ($group):" . $data , LOGGER_PRIO_INFO );
+				$key = $this->getKey( $id, $group );
+                return $this->cache->set( $key, $data, $this->lifeTime );
+            } else
+                return true;
+        }
+		
+		/** 
+		 * Works in the same way as Cache::setData does, but instead of setting single values,
+		 * it assumes that the value we're setting for the given key is part of an array of values. This
+		 * method is useful for data which we know is not unique.
+		 */
+		function setMultipleData( $id, $group, $data )
+		{
+            if( $this->_cacheCategoryEnabled($group) ) {
+                $this->log->debug("Multiple Caching $id ($group):" . $data , LOGGER_PRIO_INFO );
+
+				$currentData = $this->getData( $id, $group );
+				if( !$currentData ) $currentData = Array();
+				
+				/**
+				 * :TODO:
+				 * It's clear that we're only going to cache DbObjects using this method
+				 * but what happens if we don't? Should we force developers to provide a method
+				 * to uniquely identify their own objects? We definitely need a unique id here so that
+				 * the array doesn't grow forever...
+				 */
+				$currentData[$data->getId()] = $data;
+				
+                return $this->setData( $id, "$group", $currentData );
+            } else
+                return true;
+			
+		}
+
+        function getData( $id, $group )
+        {
+			global $__memcache_hits;			
+			global $__memcache_queries;
+			global $__memcache_misses;		
+		
+            if( $this->_cacheCategoryEnabled($group) ) {
+			
+				$__memcache_queries++;
+
+                $key = $this->getKey( $id, $group );
+                $data = $this->cache->get( $key );
+
+                    if ($data) {
+                        $this->log->debug("Cache hit for $id ($group): $data", LOGGER_PRIO_INFO );
+						$__memcache_hits++;
+					}
+                    else {
+                        $this->log->debug("Cache miss for $id ($group)", LOGGER_PRIO_WARN );
+						$__memcache_misses++;						
+					}
+
+                return $data;
+            } else {
+                return false;
+			}
+
+        }
+
+        function removeData( $id, $group )
+        {
+            if( $this->_cacheCategoryEnabled($group) ) {
+                $this->log->debug("Removing from cache $id ($group)", LOGGER_PRIO_WARN );
+				$key = $this->getKey( $id, $group );
+                return $this->cache->delete( $key, $group );
+            } else
+                return true;
+        }
+
+        function clearCacheByGroup( $group )
+        {
+            $this->log->debug( "Removing cache group does not implement in Memcached Client yet." );
+            return true;
+        }
+
+        function clearCache()
+        {
+            $this->log->debug("Cleaning the cache", LOGGER_PRIO_WARN );
+            return $this->cache->flush_all();
+        }
+
+        function disableCacheForCategory( $category )
+        {
+            $this->_disabledCacheCategories = array_merge( $this->_disabledCacheCategories,
+                                                           array($category) );
+            return true;
+        }
+
+        function _cacheCategoryEnabled( $category )
+        {
+            if( in_array($category, $this->_disabledCacheCategories) ) {
+                $this->log->debug("Caching category $group disabled", LOGGER_PRIO_INFO );
+                return false;
+            } else
+                return true;
+        }
+		
+		/**
+		 * returns the total count of cache hits, miss and total queries over the lifetime of the
+		 * script so far.
+		 *
+		 * @return An array with 3 keys: "hits", "total" and "miss"
+		 */
+		function getCacheStats()
+		{
+			global $__memcache_hits;
+			global $__memcache_misses;
+			global $__memcache_queries;
+		
+			return( Array( "total" => $__memcache_queries,
+			               "hits"  => $__memcache_hits,
+						   "miss"  => $__memcache_misses )); 
+		}
+		
+		function getKey( $id, $group )
+		{
+			return $group.':'.$id;	
+		}
+    }
+?>
\ No newline at end of file


Property changes on: plog/trunk/class/cache/memcache.class.php
___________________________________________________________________
Name: svn:executable
   + *

Modified: plog/trunk/config/config.properties.php
===================================================================
--- plog/trunk/config/config.properties.php	2006-09-24 12:13:51 UTC (rev 4037)
+++ plog/trunk/config/config.properties.php	2006-09-24 15:17:20 UTC (rev 4038)
@@ -5,7 +5,7 @@
 # Installation instructions:
 #   NEW INSTALL
 #   Leave these values blank,
-#   and go to the URL where you installed pLog
+#   and go to the URL where you installed LifeType
 #   and look at /wizard.php and type the appropriate
 #   values in there.
 #
@@ -26,11 +26,19 @@
 #   (note, if upgrading between minor releases:
 #   1.0 to 1.0.1, etc. you shouldn't run the wizard)
 
-$config["db_host"] = "";
-$config["db_username"] = "";
-$config["db_password"] = "";
-$config["db_database"] = "";
-$config["db_prefix"] = "";
-$config["db_character_set"] = "default";
+$config['db_host'] = 'localhost';
+$config['db_username'] = 'root';
+$config['db_password'] = '1796sz';
+$config['db_database'] = 'lifetype_104';
 $config["db_persistent"] = true;
-?>
\ No newline at end of file
+$config['db_character_set'] = 'latin1';
+
+#
+# the database prefix will be appended to the name of each database tables in case you want
+# to have more than one version of plog running at the same time, such as the stable and
+# unstable one for testing. Each one could use a different prefix and therefore they could
+# coexist in the same unique database. If you change this after the initial configuration done
+# with the installation wizard, please make sure that you also rename the tables.
+#
+$config['db_prefix'] = 'lt_';
+?>



More information about the pLog-svn mailing list