Implements: Cache_Arithmetic | Kohana_Cache_Arithmetic
This class is a transparent base class for Cache_Memcache and should not be accessed directly.
Kohana Cache Memcache driver,
Below is an example of a memcache server configuration.
return [
// Default group
'default' => [
// Using Memcache driver
'driver' => 'memcache',
// Available server definitions
'servers' => [
// First memcache server server
[
'host' => 'localhost',
'port' => 11211,
'persistent' => false,
'weight' => 1,
'timeout' => 1,
'retry_interval' => 15,
'status' => true,
'instant_death' => true,
'failure_callback' => ['className', 'classMethod']
],
// Second memcache server
[
'host' => '192.168.1.5',
'port' => 22122,
'persistent' => true
]
],
// Use compression?
'compression' => false,
],
];
In cases where only one cache group is required, if the group is named default there is
no need to pass the group name when instantiating a cache instance.
Below are the settings available to all types of cache driver.
| Name | Required | Description |
|---|---|---|
| driver | YES | (string) The driver type to use |
| servers | YES | (array) Associative array of server details, must include a host key. (see Memcache server configuration below) |
| compression | NO | (boolean) Use data compression when caching |
The following settings should be used when defining each memcache server
| Name | Required | Description |
|---|---|---|
| host | YES | (string) The host of the memcache server, i.e. localhost; or 127.0.0.1; or memcache.domain.tld |
| port | NO | (integer) Point to the port where memcached is listening for connections. Set this parameter to 0 when using UNIX domain sockets. Default 11211 |
| persistent | NO | (boolean) Controls the use of a persistent connection. Default true |
| weight | NO | (integer) Number of buckets to create for this server which in turn control its probability of it being selected. The probability is relative to the total weight of all servers. Default 1 |
| timeout | NO | (integer) Value in seconds which will be used for connecting to the daemon. Think twice before changing the default value of 1 second - you can lose all the advantages of caching if your connection is too slow. Default 1 |
| retry_interval | NO | (integer) Controls how often a failed server will be retried, the default value is 15 seconds. Setting this parameter to -1 disables automatic retry. Default 15 |
| status | NO | (boolean) Controls if the server should be flagged as online. Default true |
| failure_callback | NO | (callback) Allows the user to specify a callback function to run upon encountering an error. The callback is run before failover is attempted. The function takes two parameters, the hostname and port of the failed server. Default null |
Class declared in MODPATH/cache/classes/Kohana/Cache/Memcache.php on line 89.
integer 2592000
integer 3600
string $defaultdefault driver to use
string(4) "file"Kohana_Cache $instancesinstances
array(0) Config $_configarray(0) array $_default_configThe default configuration for the memcached server
array(0) string $_flagsFlags to use when storing values
NULL
Memcache $_memcacheMemcache resource
NULL
Callback method for Memcache::failure_callback to use if any Memcache call
on a particular server fails. This method switches off that instance of the
server if the configuration setting instant_death is set to true.
string
$hostname
required - $hostname integer
$port
required - $port void|booleanpublic function _failed_request($hostname, $port)
{
if (!$this->_config['instant_death'])
return;
// Setup non-existent host
$host = false;
// Get host settings from configuration
foreach ($this->_config['servers'] as $server) {
// Merge the defaults, since they won't always be set
$server += $this->_default_config;
// We're looking at the failed server
if ($hostname == $server['host'] and $port == $server['port']) {
// Server to disable, since it failed
$host = $server;
continue;
}
}
if (!$host)
return;
else {
return $this->_memcache->setServerParams(
$host['host'], $host['port'], $host['timeout'], $host['retry_interval'],
// Server is offline
false, [$this, '_failed_request']
);
}
}Decrements a given value by the step value supplied. Useful for shared counters and other persistent integer based tracking.
string
$id
required - Id of cache entry to decrement int
$step
= integer 1 - Step value to decrement by integerbooleanpublic function decrement($id, $step = 1)
{
return $this->_memcache->decrement($id, $step);
}Delete a cache entry based on id
// Delete the 'foo' cache entry immediately
Cache::instance('memcache')->delete('foo');
// Delete the 'bar' cache entry after 30 seconds
Cache::instance('memcache')->delete('bar', 30);
string
$id
required - Id of entry to delete integer
$timeout
= integer 0 - Timeout of entry, if zero item is deleted immediately, otherwise the item will delete after the specified value in seconds booleanpublic function delete($id, $timeout = 0)
{
// Delete the id
return $this->_memcache->delete($this->_sanitize_id($id), $timeout);
}Delete all cache entries.
Beware of using this method when using shared memory cache systems, as it will wipe every entry within the system for all clients.
// Delete all cache entries in the default group
Cache::instance('memcache')->delete_all();
booleanpublic function delete_all()
{
$result = $this->_memcache->flush();
// We must sleep after flushing, or overwriting will not work!
// @see http://php.net/manual/en/function.memcache-flush.php#81420
sleep(1);
return $result;
}Retrieve a cached value entry by id.
// Retrieve cache entry from memcache group
$data = Cache::instance('memcache')->get('foo');
// Retrieve cache entry from memcache group and return 'bar' if miss
$data = Cache::instance('memcache')->get('foo', 'bar');
string
$id
required - Id of cache to entry string
$default
= NULL - Default value to return if cache miss mixedpublic function get($id, $default = null)
{
// Get the value from Memcache
$value = $this->_memcache->get($this->_sanitize_id($id));
// If the value wasn't found, normalise it
if ($value === false) {
$value = (null === $default) ? null : $default;
}
// Return the value
return $value;
}Increments a given value by the step value supplied. Useful for shared counters and other persistent integer based tracking.
string
$id
required - Id of cache entry to increment int
$step
= integer 1 - Step value to increment by integerbooleanpublic function increment($id, $step = 1)
{
return $this->_memcache->increment($id, $step);
}Set a value to cache with id and lifetime
$data = 'bar';
// Set 'bar' to 'foo' in memcache group for 10 minutes
if (Cache::instance('memcache')->set('foo', $data, 600))
{
// Cache was set successfully
return
}
string
$id
required - Id of cache entry mixed
$data
required - Data to set to cache integer
$lifetime
= integer 3600 - Lifetime in seconds, maximum value 2592000 booleanpublic function set($id, $data, $lifetime = 3600)
{
// If the lifetime is greater than the ceiling
if ($lifetime > Cache_Memcache::CACHE_CEILING) {
// Set the lifetime to maximum cache time
$lifetime = Cache_Memcache::CACHE_CEILING + time();
}
// Else if the lifetime is greater than zero
elseif ($lifetime > 0) {
$lifetime += time();
}
// Else
else {
// Normalise the lifetime
$lifetime = 0;
}
// Set the data to memcache
return $this->_memcache->set($this->_sanitize_id($id), $data, $this->_flags, $lifetime);
}Overload the __clone() method to prevent cloning
voidfinal public function __clone()
{
throw new Cache_Exception('Cloning of Kohana_Cache objects is forbidden');
}Getter and setter for the configuration. If no argument provided, the current configuration is returned. Otherwise the configuration is set to this class.
// Overwrite all configuration
$cache->config(['driver' => 'memcache', '...']);
// Set a new configuration setting
$cache->config('servers', ['foo' => 'bar', '...']);
// Get a configuration setting
$servers = $cache->config('servers);
mixed
$key
= NULL - Key to set to array, either array or config path mixed
$value
= NULL - Value to associate with key mixedpublic function config($key = null, $value = null)
{
if ($key === null)
return $this->_config;
if (is_array($key)) {
$this->_config = $key;
} else {
if ($value === null)
return Arr::get($this->_config, $key);
$this->_config[$key] = $value;
}
return $this;
}Creates a singleton of a Kohana Cache group. If no group is supplied the default cache group is used.
// Create an instance of the default group
$default_group = Cache::instance();
// Create an instance of a group
$foo_group = Cache::instance('foo');
// Access an instantiated group directly
$foo_group = Cache::$instances['default'];
string
$group
= NULL - The name of the cache group to use [Optional] Cachepublic static function instance($group = null)
{
// If there is no group supplied
if ($group === null) {
// Use the default setting
$group = Cache::$default;
}
if (isset(Cache::$instances[$group])) {
// Return the current group if initiated already
return Cache::$instances[$group];
}
$config = Kohana::$config->load('cache');
if (!$config->offsetExists($group)) {
throw new Cache_Exception('Failed to load Kohana Cache group: :group', [':group' => $group]);
}
$config = $config->get($group);
// Create a new cache type instance
$cache_class = 'Cache_' . ucfirst($config['driver']);
Cache::$instances[$group] = new $cache_class($config);
// Return the instance
return Cache::$instances[$group];
}Constructs the memcache Kohana_Cache object
array
$config
required - Configuration protected function __construct(array $config)
{
// Check for the memcache extention
if (!extension_loaded('memcache')) {
throw new Cache_Exception('Memcache PHP extention not loaded');
}
parent::__construct($config);
// Setup Memcache
$this->_memcache = new Memcache;
// Load servers from configuration
$servers = Arr::get($this->_config, 'servers', null);
if (!$servers) {
// Throw an exception if no server found
throw new Cache_Exception('No Memcache servers defined in configuration');
}
// Setup default server configuration
$this->_default_config = [
'host' => 'localhost',
'port' => 11211,
'persistent' => false,
'weight' => 1,
'timeout' => 1,
'retry_interval' => 15,
'status' => true,
'instant_death' => true,
'failure_callback' => [$this, '_failed_request'],
];
// Add the memcache servers to the pool
foreach ($servers as $server) {
// Merge the defined config with defaults
$server += $this->_default_config;
if (!$this->_memcache->addServer($server['host'], $server['port'], $server['persistent'], $server['weight'], $server['timeout'], $server['retry_interval'], $server['status'], $server['failure_callback'])) {
throw new Cache_Exception('Memcache could not connect to host \':host\' using port \':port\'', [':host' => $server['host'], ':port' => $server['port']]);
}
}
// Setup the flags
$this->_flags = Arr::get($this->_config, 'compression', false) ? MEMCACHE_COMPRESSED : false;
}Replaces troublesome characters with underscores.
// Sanitize a cache id
$id = $this->_sanitize_id($id);
string
$id
required - Id of cache to sanitize stringprotected function _sanitize_id($id)
{
// Change slashes and spaces to underscores
return str_replace(['/', '\\', ' '], '_', $id);
}