abstract Kohana_Cache

Kohana Cache provides a common interface to a variety of caching engines. Tags are supported where available natively to the cache system. Kohana Cache supports multiple instances of cache engines through a grouped singleton pattern.

Supported cache engines

• APC
• eAccelerator
• File
• Memcache
• Memcached-tags
• SQLite
• Xcache

Introduction to caching

Caching should be implemented with consideration. Generally, caching the result of resources is faster than reprocessing them. Choosing what, how and when to cache is vital. PHP APC is presently one of the fastest caching systems available, closely followed by Memcache. SQLite and File caching are two of the slowest cache methods, however usually faster than reprocessing a complex set of instructions.

Caching engines that use memory are considerably faster than the file based alternatives. But memory is limited whereas disk space is plentiful. If caching large datasets it is best to use file caching.

Configuration settings

Kohana Cache uses configuration groups to create cache instances. A configuration group can use any supported driver, with successive groups using the same driver type if required.

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
                    array(
                         'host'       => 'localhost',
                         'port'       => 11211,
                         'persistent' => FALSE
                    )
             ),
             '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.

Details of the settings specific to each driver are available within the drivers documentation.

System requirements

• Kohana 3.0.x
• PHP 5.2.4 or greater

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.php on line 77.

Properties

Methods

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

// Overwrite all configuration
$cache->config(array('driver' => 'memcache', '...'));

// Set a new configuration setting
$cache->config('servers', array(
     'foo' => 'bar',
     '...'
     ));

// Get a configuration setting
$servers = $cache->config('servers);

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

// Delete 'foo' entry from the default group
Cache::instance()->delete('foo');

// Delete 'foo' entry from the memcache group
Cache::instance('memcache')->delete('foo')

abstract public function delete($id);

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

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

abstract public function delete_all();

// Retrieve cache entry from default group
$data = Cache::instance()->get('foo');

// Retrieve cache entry from default group and return 'bar' if miss
$data = Cache::instance()->get('foo', 'bar');

// Retrieve cache entry from memcache group
$data = Cache::instance('memcache')->get('foo');

abstract public function get($id, $default = NULL);

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

	if ( ! $config->offsetExists($group))
	{
		throw new 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];
}

$data = 'bar';

// Set 'bar' to 'foo' in default group, using default expiry
Cache::instance()->set('foo', $data);

// Set 'bar' to 'foo' in default group for 30 seconds
Cache::instance()->set('foo', $data, 30);

// Set 'bar' to 'foo' in memcache group for 10 minutes
if (Cache::instance('memcache')->set('foo', $data, 600))
{
     // Cache was set successfully
     return
}

abstract public function set($id, $data, $lifetime = 3600);

protected function __construct(array $config)
{
	$this->config($config);
}

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