Reverted cache layer
This commit is contained in:
Josh Sherman
parent
026c8137e9
commit
a0074337a3
2 changed files with 568 additions and 216 deletions
|
|
@ -9,7 +9,7 @@
|
|||
* Redistribution of these files must retain the above copyright notice.
|
||||
*
|
||||
* @author Josh Sherman <pickles@joshtronic.com>
|
||||
* @copyright Copyright 2007-2013, Josh Sherman
|
||||
* @copyright Copyright 2007-2012, Josh Sherman
|
||||
* @license http://www.opensource.org/licenses/mit-license.html
|
||||
* @package PICKLES
|
||||
* @link https://github.com/joshtronic/pickles
|
||||
|
|
@ -18,31 +18,24 @@
|
|||
/**
|
||||
* Cache Class
|
||||
*
|
||||
* Wrapper class for interfacing with Redis and Memcached as key/value
|
||||
* stores for caching data. Wrapper provides graceful failover when a
|
||||
* caching server is not available. The syntax is designed around the API
|
||||
* for Memcached() to provide a consistent experience across datastores.
|
||||
* Support for Memcached is currently using the Memcache() library due to
|
||||
* some bugginess with Memcached(). The plan is to migrate to Memcached()
|
||||
* in the future. Redis interaction is done via phpredis. Keys are
|
||||
* optionally namespaced and keys are forced to lowercase for consistency.
|
||||
|
||||
* @link http://www.memcached.org/
|
||||
* Wrapper class for Memcache() to allow for better error handling when the
|
||||
* Memcached server is unavailable. Designed around the syntax for Memcached()
|
||||
* to allow for an easier transistion to the aforementioned in the future. I
|
||||
* don't entirely remember specifics, but the reason for not using Memcached()
|
||||
* was due to an unexplainable bug in the version in the repository for Ubuntu
|
||||
* 10.04 LTS. Memcached() does support more of the memcached protocol and will
|
||||
* eventually be what PICKLES uses. Keys are forced to be uppercase for
|
||||
* consistencies sake as I've been burned by the case sensitivity due to typos
|
||||
* in my code.
|
||||
*
|
||||
* Requires php5-memcache
|
||||
*
|
||||
* @link http://us.php.net/manual/en/book.memcache.php
|
||||
* @link http://packages.ubuntu.com/lucid/php5-memcache
|
||||
* @link http://redis.io
|
||||
* @link https://github.com/nicolasff/phpredis
|
||||
* @link http://www.memcached.org/
|
||||
*/
|
||||
class Cache extends Object
|
||||
{
|
||||
/**
|
||||
* Cache handler
|
||||
*
|
||||
* @access private
|
||||
* @var string memcached or redis
|
||||
*/
|
||||
private $handler = null;
|
||||
|
||||
/**
|
||||
* Hostname for the Memcached Server
|
||||
*
|
||||
|
|
@ -57,15 +50,7 @@ class Cache extends Object
|
|||
* @access private
|
||||
* @var integer
|
||||
*/
|
||||
private $port = null;
|
||||
|
||||
/**
|
||||
* Database to use (Redis-only)
|
||||
*
|
||||
* @access private
|
||||
* @var integer
|
||||
*/
|
||||
private $database = 0;
|
||||
private $port = 11211;
|
||||
|
||||
/**
|
||||
* Namespace (prefix)
|
||||
|
|
@ -86,9 +71,12 @@ class Cache extends Object
|
|||
/**
|
||||
* Constructor
|
||||
*
|
||||
* Sets up our variables
|
||||
* Sets up our connection variables.
|
||||
*
|
||||
* @param string $hostname optional hostname to connect to
|
||||
* @param string $database optional port to use
|
||||
*/
|
||||
public function __construct()
|
||||
public function __construct($hostname = null, $port = null)
|
||||
{
|
||||
parent::__construct();
|
||||
|
||||
|
|
@ -98,37 +86,20 @@ class Cache extends Object
|
|||
{
|
||||
$datasource = $this->config->datasources[$this->config->pickles['cache']];
|
||||
|
||||
if (!isset($datasource['type']))
|
||||
foreach (array('hostname', 'port', 'namespace') as $variable)
|
||||
{
|
||||
throw new Exception('You must specify the datasource\'s type');
|
||||
}
|
||||
|
||||
$this->hostname = isset($datasource['hostname']) ? $datasource['hostname'] : 'localhost';
|
||||
|
||||
switch ($datasource['type'])
|
||||
{
|
||||
case 'memcache':
|
||||
case 'memcached':
|
||||
$this->handler = 'memcached';
|
||||
$this->port = isset($datasource['port']) ? $datasource['port'] : 11211;
|
||||
break;
|
||||
|
||||
case 'redis':
|
||||
$this->handler = 'redis';
|
||||
$this->port = isset($datasource['port']) ? $datasource['port'] : 6379;
|
||||
$this->database = isset($datasource['database']) ? $datasource['database'] : 0;
|
||||
break;
|
||||
|
||||
default:
|
||||
throw new Exception('The specified datasource type "' . $datasource['type'] . '" is unsupported.');
|
||||
}
|
||||
|
||||
if (isset($datasource['namespace']) && $datasource['namespace'] != '')
|
||||
{
|
||||
$this->namespace = $datasource['namespace'] . ':';
|
||||
if (isset($datasource[$variable]))
|
||||
{
|
||||
$this->$variable = $datasource[$variable];
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if ($this->namespace != '')
|
||||
{
|
||||
$this->namespace .= '-';
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -167,62 +138,11 @@ class Cache extends Object
|
|||
{
|
||||
if ($this->connection === null)
|
||||
{
|
||||
switch ($this->handler)
|
||||
{
|
||||
case 'memcached':
|
||||
$this->connection = new Memcache();
|
||||
break;
|
||||
|
||||
case 'redis':
|
||||
$this->connection = new Redis();
|
||||
break;
|
||||
}
|
||||
$this->connection = new Memcache();
|
||||
$this->connection->connect($this->hostname, $this->port);
|
||||
}
|
||||
|
||||
$connected = $this->connection->connect($this->hostname, $this->port);
|
||||
|
||||
if ($connected && $this->database != 0)
|
||||
{
|
||||
$this->connection->select($this->database);
|
||||
}
|
||||
|
||||
return $connected;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set Key
|
||||
*
|
||||
* Sets key to the specified value.
|
||||
*
|
||||
* @param string $key key to set
|
||||
* @param mixed $value value to set
|
||||
* @param integer $expiration optional expiration, defaults to 5 minutes
|
||||
* @return boolean status of writing the data to the key
|
||||
*/
|
||||
public function set($key, $value, $expire = 300)
|
||||
{
|
||||
$key = strtolower($key);
|
||||
|
||||
if ($this->open())
|
||||
{
|
||||
switch ($this->handler)
|
||||
{
|
||||
case 'memcached':
|
||||
return $this->connection->set(strtolower($this->namespace . $key), $value, 0, $expire);
|
||||
break;
|
||||
|
||||
case 'redis':
|
||||
if (is_array($value))
|
||||
{
|
||||
$value = 'JSON:' . json_encode($value);
|
||||
}
|
||||
|
||||
return $this->connection->set(strtolower($this->namespace . $key), $value, $expire);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
return false;
|
||||
return true;
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -237,53 +157,45 @@ class Cache extends Object
|
|||
{
|
||||
if ($this->open())
|
||||
{
|
||||
// Namespaces keys
|
||||
if (is_array($keys))
|
||||
{
|
||||
foreach ($keys as $index => $key)
|
||||
{
|
||||
$keys[$index] = strtolower($this->namespace . $key);
|
||||
$keys[$index] = strtoupper($this->namespace . $key);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
$keys = strtolower($this->namespace . $keys);
|
||||
$keys = strtoupper($this->namespace . $keys);
|
||||
}
|
||||
|
||||
switch ($this->handler)
|
||||
{
|
||||
case 'memcached':
|
||||
return $this->connection->get($keys);
|
||||
break;
|
||||
return $this->connection->get($keys);
|
||||
}
|
||||
|
||||
case 'redis':
|
||||
if (is_array($keys))
|
||||
{
|
||||
$values = $this->connection->mGet($keys);
|
||||
return false;
|
||||
}
|
||||
|
||||
foreach ($values as $index => $value)
|
||||
{
|
||||
if (substr($value, 0, 5) == 'JSON:')
|
||||
{
|
||||
$values[$index] = json_decode(substr($value, 5), true);
|
||||
}
|
||||
}
|
||||
/**
|
||||
* Set Key
|
||||
*
|
||||
* Sets key to the specified value. I've found that compression can lead to
|
||||
* issues with integers and can slow down the storage and retrieval of data
|
||||
* (defeats the purpose of caching if you ask me) and isn't supported. I've
|
||||
* also been burned by data inadvertantly being cached for infinity, hence
|
||||
* the 5 minute default.
|
||||
*
|
||||
* @param string $key key to set
|
||||
* @param mixed $value value to set
|
||||
* @param integer $expiration optional expiration, defaults to 5 minutes
|
||||
* @return boolean status of writing the data to the key
|
||||
*/
|
||||
public function set($key, $value, $expire = 300)
|
||||
{
|
||||
$key = strtoupper($key);
|
||||
|
||||
return $values;
|
||||
}
|
||||
else
|
||||
{
|
||||
$value = $this->connection->get($keys);
|
||||
|
||||
if (substr($value, 0, 5) == 'JSON:')
|
||||
{
|
||||
$value = json_decode(substr($value, 5), true);
|
||||
}
|
||||
|
||||
return $value;
|
||||
}
|
||||
break;
|
||||
}
|
||||
if ($this->open())
|
||||
{
|
||||
return $this->connection->set(strtoupper($this->namespace . $key), $value, 0, $expire);
|
||||
}
|
||||
|
||||
return false;
|
||||
|
|
@ -309,7 +221,7 @@ class Cache extends Object
|
|||
// Memcache() doesn't let you pass an array to delete all records the same way you can with get()
|
||||
foreach ($keys as $key)
|
||||
{
|
||||
$this->connection->delete(strtolower($this->namespace . $key));
|
||||
$this->connection->delete(strtoupper($this->namespace . $key));
|
||||
}
|
||||
|
||||
return true;
|
||||
|
|
@ -318,83 +230,23 @@ class Cache extends Object
|
|||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Change
|
||||
*
|
||||
* Increment / decrement a variable by a value
|
||||
*
|
||||
* @param string $direction increment or decrement
|
||||
* @param string $key key to increment
|
||||
* @param integer $value increment by value
|
||||
* @return mixed new value or false if unable to connect
|
||||
*/
|
||||
public function change($direction, $key, $value = 1)
|
||||
{
|
||||
if ($this->handler == 'redis')
|
||||
{
|
||||
switch ($direction)
|
||||
{
|
||||
case 'increment': $direction = 'incr'; break;
|
||||
case 'decrement': $direction = 'decr'; break;
|
||||
}
|
||||
|
||||
if ($value > 1)
|
||||
{
|
||||
$direction .= 'By';
|
||||
}
|
||||
}
|
||||
|
||||
$key = strtolower($this->namespace . $key);
|
||||
|
||||
if ($this->open())
|
||||
{
|
||||
// Memcache::*crement() doesn't create the key
|
||||
if ($this->handler == 'memcached')
|
||||
{
|
||||
if ($this->connection->add($key, $value) === false)
|
||||
{
|
||||
return $this->connection->$direction($key, $value);
|
||||
}
|
||||
else
|
||||
{
|
||||
return $value;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
return $this->connection->$direction($key, $value);
|
||||
}
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Increment Key
|
||||
*
|
||||
* Increments the value of an existing key.
|
||||
*
|
||||
* @param string $key key to increment
|
||||
* @param integer $value increment by value
|
||||
* @return mixed new value or false if unable to connect
|
||||
* @return boolean status of incrementing the key
|
||||
* @todo Wondering if I should check the key and set to 1 if it's new
|
||||
*/
|
||||
public function increment($key, $value = 1)
|
||||
public function increment($key)
|
||||
{
|
||||
return $this->change('increment', $key, $value);
|
||||
}
|
||||
if ($this->open())
|
||||
{
|
||||
return $this->connection->increment(strtoupper($this->namespace . $key));
|
||||
}
|
||||
|
||||
/**
|
||||
* Decrement Key
|
||||
*
|
||||
* Decrements the value of an existing key.
|
||||
*
|
||||
* @param string $key key to decrement
|
||||
* @param integer $value decrement by value
|
||||
* @return mixed new value or false if unable to connect
|
||||
*/
|
||||
public function decrement($key, $value = 1)
|
||||
{
|
||||
return $this->change('decrement', $key, $value);
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
500
jar.php
500
jar.php
|
|
@ -579,6 +579,256 @@ class Browser extends Object
|
|||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Caching System for PICKLES
|
||||
*
|
||||
* PHP version 5
|
||||
*
|
||||
* Licensed under The MIT License
|
||||
* Redistribution of these files must retain the above copyright notice.
|
||||
*
|
||||
* @author Josh Sherman <pickles@joshtronic.com>
|
||||
* @copyright Copyright 2007-2012, Josh Sherman
|
||||
* @license http://www.opensource.org/licenses/mit-license.html
|
||||
* @package PICKLES
|
||||
* @link https://github.com/joshtronic/pickles
|
||||
*/
|
||||
|
||||
/**
|
||||
* Cache Class
|
||||
*
|
||||
* Wrapper class for Memcache() to allow for better error handling when the
|
||||
* Memcached server is unavailable. Designed around the syntax for Memcached()
|
||||
* to allow for an easier transistion to the aforementioned in the future. I
|
||||
* don't entirely remember specifics, but the reason for not using Memcached()
|
||||
* was due to an unexplainable bug in the version in the repository for Ubuntu
|
||||
* 10.04 LTS. Memcached() does support more of the memcached protocol and will
|
||||
* eventually be what PICKLES uses. Keys are forced to be uppercase for
|
||||
* consistencies sake as I've been burned by the case sensitivity due to typos
|
||||
* in my code.
|
||||
*
|
||||
* Requires php5-memcache
|
||||
*
|
||||
* @link http://us.php.net/manual/en/book.memcache.php
|
||||
* @link http://packages.ubuntu.com/lucid/php5-memcache
|
||||
* @link http://www.memcached.org/
|
||||
*/
|
||||
class Cache extends Object
|
||||
{
|
||||
/**
|
||||
* Hostname for the Memcached Server
|
||||
*
|
||||
* @access private
|
||||
* @var string
|
||||
*/
|
||||
private $hostname = 'localhost';
|
||||
|
||||
/**
|
||||
* Port to use to connect
|
||||
*
|
||||
* @access private
|
||||
* @var integer
|
||||
*/
|
||||
private $port = 11211;
|
||||
|
||||
/**
|
||||
* Namespace (prefix)
|
||||
*
|
||||
* @access private
|
||||
* @var string
|
||||
*/
|
||||
private $namespace = '';
|
||||
|
||||
/**
|
||||
* Connection resource to Memcached
|
||||
*
|
||||
* @access private
|
||||
* @var object
|
||||
*/
|
||||
private $connection = null;
|
||||
|
||||
/**
|
||||
* Constructor
|
||||
*
|
||||
* Sets up our connection variables.
|
||||
*
|
||||
* @param string $hostname optional hostname to connect to
|
||||
* @param string $database optional port to use
|
||||
*/
|
||||
public function __construct($hostname = null, $port = null)
|
||||
{
|
||||
parent::__construct();
|
||||
|
||||
if ($this->config->pickles['cache'])
|
||||
{
|
||||
if (isset($this->config->datasources[$this->config->pickles['cache']]))
|
||||
{
|
||||
$datasource = $this->config->datasources[$this->config->pickles['cache']];
|
||||
|
||||
foreach (array('hostname', 'port', 'namespace') as $variable)
|
||||
{
|
||||
if (isset($datasource[$variable]))
|
||||
{
|
||||
$this->$variable = $datasource[$variable];
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if ($this->namespace != '')
|
||||
{
|
||||
$this->namespace .= '-';
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Destructor
|
||||
*
|
||||
* Closes the connection when the object dies.
|
||||
*/
|
||||
public function __destruct()
|
||||
{
|
||||
if ($this->connection)
|
||||
{
|
||||
$this->connection->close();
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Get Instance
|
||||
*
|
||||
* Let's the parent class do all the work.
|
||||
*
|
||||
* @static
|
||||
* @param string $class name of the class to instantiate
|
||||
* @return object self::$instance instance of the Cache class
|
||||
*/
|
||||
public static function getInstance($class = 'Cache')
|
||||
{
|
||||
return parent::getInstance($class);
|
||||
}
|
||||
|
||||
/**
|
||||
* Opens Connection
|
||||
*
|
||||
* Establishes a connection to the memcached server.
|
||||
*/
|
||||
public function open()
|
||||
{
|
||||
if ($this->connection === null)
|
||||
{
|
||||
$this->connection = new Memcache();
|
||||
$this->connection->connect($this->hostname, $this->port);
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get Key
|
||||
*
|
||||
* Gets the value of the key(s) and returns it.
|
||||
*
|
||||
* @param mixed $keys key(s) to retrieve
|
||||
* @return mixed value(s) of the requested key(s), false if not set
|
||||
*/
|
||||
public function get($keys)
|
||||
{
|
||||
if ($this->open())
|
||||
{
|
||||
if (is_array($keys))
|
||||
{
|
||||
foreach ($keys as $index => $key)
|
||||
{
|
||||
$keys[$index] = strtoupper($this->namespace . $key);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
$keys = strtoupper($this->namespace . $keys);
|
||||
}
|
||||
|
||||
return $this->connection->get($keys);
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set Key
|
||||
*
|
||||
* Sets key to the specified value. I've found that compression can lead to
|
||||
* issues with integers and can slow down the storage and retrieval of data
|
||||
* (defeats the purpose of caching if you ask me) and isn't supported. I've
|
||||
* also been burned by data inadvertantly being cached for infinity, hence
|
||||
* the 5 minute default.
|
||||
*
|
||||
* @param string $key key to set
|
||||
* @param mixed $value value to set
|
||||
* @param integer $expiration optional expiration, defaults to 5 minutes
|
||||
* @return boolean status of writing the data to the key
|
||||
*/
|
||||
public function set($key, $value, $expire = 300)
|
||||
{
|
||||
$key = strtoupper($key);
|
||||
|
||||
if ($this->open())
|
||||
{
|
||||
return $this->connection->set(strtoupper($this->namespace . $key), $value, 0, $expire);
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Delete Key
|
||||
*
|
||||
* Deletes the specified key(s).
|
||||
*
|
||||
* @param mixed $keys key(s) to delete
|
||||
* @return boolean status of deleting the key
|
||||
*/
|
||||
public function delete($keys)
|
||||
{
|
||||
if ($this->open())
|
||||
{
|
||||
if (!is_array($keys))
|
||||
{
|
||||
$keys = array($keys);
|
||||
}
|
||||
|
||||
// Memcache() doesn't let you pass an array to delete all records the same way you can with get()
|
||||
foreach ($keys as $key)
|
||||
{
|
||||
$this->connection->delete(strtoupper($this->namespace . $key));
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Increment Key
|
||||
*
|
||||
* Increments the value of an existing key.
|
||||
*
|
||||
* @param string $key key to increment
|
||||
* @return boolean status of incrementing the key
|
||||
* @todo Wondering if I should check the key and set to 1 if it's new
|
||||
*/
|
||||
public function increment($key)
|
||||
{
|
||||
if ($this->open())
|
||||
{
|
||||
return $this->connection->increment(strtoupper($this->namespace . $key));
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Caching System for PICKLES
|
||||
*
|
||||
|
|
@ -977,6 +1227,256 @@ class Cache extends Object
|
|||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Caching System for PICKLES
|
||||
*
|
||||
* PHP version 5
|
||||
*
|
||||
* Licensed under The MIT License
|
||||
* Redistribution of these files must retain the above copyright notice.
|
||||
*
|
||||
* @author Josh Sherman <pickles@joshtronic.com>
|
||||
* @copyright Copyright 2007-2012, Josh Sherman
|
||||
* @license http://www.opensource.org/licenses/mit-license.html
|
||||
* @package PICKLES
|
||||
* @link https://github.com/joshtronic/pickles
|
||||
*/
|
||||
|
||||
/**
|
||||
* Cache Class
|
||||
*
|
||||
* Wrapper class for Memcache() to allow for better error handling when the
|
||||
* Memcached server is unavailable. Designed around the syntax for Memcached()
|
||||
* to allow for an easier transistion to the aforementioned in the future. I
|
||||
* don't entirely remember specifics, but the reason for not using Memcached()
|
||||
* was due to an unexplainable bug in the version in the repository for Ubuntu
|
||||
* 10.04 LTS. Memcached() does support more of the memcached protocol and will
|
||||
* eventually be what PICKLES uses. Keys are forced to be uppercase for
|
||||
* consistencies sake as I've been burned by the case sensitivity due to typos
|
||||
* in my code.
|
||||
*
|
||||
* Requires php5-memcache
|
||||
*
|
||||
* @link http://us.php.net/manual/en/book.memcache.php
|
||||
* @link http://packages.ubuntu.com/lucid/php5-memcache
|
||||
* @link http://www.memcached.org/
|
||||
*/
|
||||
class Cache extends Object
|
||||
{
|
||||
/**
|
||||
* Hostname for the Memcached Server
|
||||
*
|
||||
* @access private
|
||||
* @var string
|
||||
*/
|
||||
private $hostname = 'localhost';
|
||||
|
||||
/**
|
||||
* Port to use to connect
|
||||
*
|
||||
* @access private
|
||||
* @var integer
|
||||
*/
|
||||
private $port = 11211;
|
||||
|
||||
/**
|
||||
* Namespace (prefix)
|
||||
*
|
||||
* @access private
|
||||
* @var string
|
||||
*/
|
||||
private $namespace = '';
|
||||
|
||||
/**
|
||||
* Connection resource to Memcached
|
||||
*
|
||||
* @access private
|
||||
* @var object
|
||||
*/
|
||||
private $connection = null;
|
||||
|
||||
/**
|
||||
* Constructor
|
||||
*
|
||||
* Sets up our connection variables.
|
||||
*
|
||||
* @param string $hostname optional hostname to connect to
|
||||
* @param string $database optional port to use
|
||||
*/
|
||||
public function __construct($hostname = null, $port = null)
|
||||
{
|
||||
parent::__construct();
|
||||
|
||||
if ($this->config->pickles['cache'])
|
||||
{
|
||||
if (isset($this->config->datasources[$this->config->pickles['cache']]))
|
||||
{
|
||||
$datasource = $this->config->datasources[$this->config->pickles['cache']];
|
||||
|
||||
foreach (array('hostname', 'port', 'namespace') as $variable)
|
||||
{
|
||||
if (isset($datasource[$variable]))
|
||||
{
|
||||
$this->$variable = $datasource[$variable];
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if ($this->namespace != '')
|
||||
{
|
||||
$this->namespace .= '-';
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Destructor
|
||||
*
|
||||
* Closes the connection when the object dies.
|
||||
*/
|
||||
public function __destruct()
|
||||
{
|
||||
if ($this->connection)
|
||||
{
|
||||
$this->connection->close();
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Get Instance
|
||||
*
|
||||
* Let's the parent class do all the work.
|
||||
*
|
||||
* @static
|
||||
* @param string $class name of the class to instantiate
|
||||
* @return object self::$instance instance of the Cache class
|
||||
*/
|
||||
public static function getInstance($class = 'Cache')
|
||||
{
|
||||
return parent::getInstance($class);
|
||||
}
|
||||
|
||||
/**
|
||||
* Opens Connection
|
||||
*
|
||||
* Establishes a connection to the memcached server.
|
||||
*/
|
||||
public function open()
|
||||
{
|
||||
if ($this->connection === null)
|
||||
{
|
||||
$this->connection = new Memcache();
|
||||
$this->connection->connect($this->hostname, $this->port);
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get Key
|
||||
*
|
||||
* Gets the value of the key(s) and returns it.
|
||||
*
|
||||
* @param mixed $keys key(s) to retrieve
|
||||
* @return mixed value(s) of the requested key(s), false if not set
|
||||
*/
|
||||
public function get($keys)
|
||||
{
|
||||
if ($this->open())
|
||||
{
|
||||
if (is_array($keys))
|
||||
{
|
||||
foreach ($keys as $index => $key)
|
||||
{
|
||||
$keys[$index] = strtoupper($this->namespace . $key);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
$keys = strtoupper($this->namespace . $keys);
|
||||
}
|
||||
|
||||
return $this->connection->get($keys);
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set Key
|
||||
*
|
||||
* Sets key to the specified value. I've found that compression can lead to
|
||||
* issues with integers and can slow down the storage and retrieval of data
|
||||
* (defeats the purpose of caching if you ask me) and isn't supported. I've
|
||||
* also been burned by data inadvertantly being cached for infinity, hence
|
||||
* the 5 minute default.
|
||||
*
|
||||
* @param string $key key to set
|
||||
* @param mixed $value value to set
|
||||
* @param integer $expiration optional expiration, defaults to 5 minutes
|
||||
* @return boolean status of writing the data to the key
|
||||
*/
|
||||
public function set($key, $value, $expire = 300)
|
||||
{
|
||||
$key = strtoupper($key);
|
||||
|
||||
if ($this->open())
|
||||
{
|
||||
return $this->connection->set(strtoupper($this->namespace . $key), $value, 0, $expire);
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Delete Key
|
||||
*
|
||||
* Deletes the specified key(s).
|
||||
*
|
||||
* @param mixed $keys key(s) to delete
|
||||
* @return boolean status of deleting the key
|
||||
*/
|
||||
public function delete($keys)
|
||||
{
|
||||
if ($this->open())
|
||||
{
|
||||
if (!is_array($keys))
|
||||
{
|
||||
$keys = array($keys);
|
||||
}
|
||||
|
||||
// Memcache() doesn't let you pass an array to delete all records the same way you can with get()
|
||||
foreach ($keys as $key)
|
||||
{
|
||||
$this->connection->delete(strtoupper($this->namespace . $key));
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Increment Key
|
||||
*
|
||||
* Increments the value of an existing key.
|
||||
*
|
||||
* @param string $key key to increment
|
||||
* @return boolean status of incrementing the key
|
||||
* @todo Wondering if I should check the key and set to 1 if it's new
|
||||
*/
|
||||
public function increment($key)
|
||||
{
|
||||
if ($this->open())
|
||||
{
|
||||
return $this->connection->increment(strtoupper($this->namespace . $key));
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Configuration Class File for PICKLES
|
||||
*
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue