Kohana_Cache_Memcache
extends Cache
extends Kohana_Cache

Kohana Cache Memcache driver,

Supported cache engines

• Memcache
• Memcached-tags

Configuration example

Below is an example of a memcache server configuration.

return array(
     'default'   => array(                          // Default group
             'driver'         => 'memcache',        // using Memcache driver
             'servers'        => array(             // Available server definitions
                    // First memcache server server
                    array(
                         'host'             => 'localhost',
                         'port'             => 11211,
                         'persistent'       => FALSE
                         'weight'           => 1,
                         'timeout'          => 1,
                         'retry_interval'   => 15,
                         'status'           => TRUE,
            'instant_death'    => TRUE,
                         'failure_callback' => array('className', 'classMethod')
                    ),
                    // Second memcache server
                    array(
                         'host'             => '192.168.1.5',
                         'port'             => 22122,
                         'persistent'       => TRUE
                    )
             ),
             'compression'    => FALSE,             // Use compression?
      ),
)

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.

General cache group configuration settings

Below are the settings available to all types of cache driver.

Memcache server configuration

The following settings should be used when defining each memcache server

System requirements

• Kohana 3.0.x
• PHP 5.2.4 or greater
• Memcache (plus Memcached-tags for native tagging support)
• Zlib

package

Kohana/Cache

category

Base

version

2.0

author

Kohana Team

copyright

© 2009-2012 Kohana Team

license

http://kohanaphp.com/license

Class declared in MODPATH/cache/classes/kohana/cache/memcache.php on line 83.

Properties

Methods

public 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'],
			FALSE, // Server is offline
			array($this, '_failed_request'
			));
	}
}

// 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);

public function delete($id, $timeout = 0)
{
	// Delete the id
	return $this->_memcache->delete($this->_sanitize_id($id), $timeout);
}

// Delete all cache entries in the default group
Cache::instance('memcache')->delete_all();

public 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 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');

public 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;
}

$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
}

public 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);
}

public function __clone()
{
	throw new Kohana_Cache_Exception('Cloning of Kohana_Cache objects is forbidden');
}

// 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'];

public 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('cache');

	if ( ! $config->offsetExists($group))
	{
		throw new Kohana_Cache_Exception('Failed to load Kohana Cache group: :group', array(':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];
}

protected function __construct(array $config)
{
	// Check for the memcache extention
	if ( ! extension_loaded('memcache'))
	{
		throw new Kohana_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 Kohana_Cache_Exception('No Memcache servers defined in configuration');
	}

	// Setup default server configuration
	$this->_default_config = array(
			'host'             => 'localhost',
			'port'             => 11211,
			'persistent'       => FALSE,
			'weight'           => 1,
			'timeout'          => 1,
			'retry_interval'   => 15,
			'status'           => TRUE,
			'instant_death'	   => TRUE,
			'failure_callback' => array($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 Kohana_Cache_Exception('Memcache could not connect to host \':host\' using port \':port\'', array(':host' => $server['host'], ':port' => $server['port']));
		}
	}

	// Setup the flags
	$this->_flags = Arr::get($this->_config, 'compression', FALSE) ? MEMCACHE_COMPRESSED : FALSE;
}

// Sanitize a cache id
$id = $this->_sanitize_id($id);

protected function _sanitize_id($id)
{
	// Change slashes and spaces to underscores
	return str_replace(array('/', '\\', ' '), '_', $id);
}