Modules

Kohana_Cache_MemcacheTag
extends Cache_Memcache
extends Kohana_Cache_Memcache
extends Cache
extends Kohana_Cache

Implements: Cache_Arithmetic | Kohana_Cache_Arithmetic | Cache_Tagging | Kohana_Cache_Tagging

This class is a transparent base class for Cache_MemcacheTag and should not be accessed directly.

See Kohana_Cache_Memcache

package
Kohana/Cache
category
Base
version
2.0
author
Kohana Team
copyright
© 2009-2012 Kohana Team
license
https://kohana.top/license
deprecated
3.4.0

Class declared in MODPATH/cache/classes/Kohana/Cache/MemcacheTag.php on line 14.

Constants

CACHE_CEILING

integer 2592000

DEFAULT_EXPIRE

integer 3600

Properties

public static string $default

default driver to use

string(4) "file"

public static Kohana_Cache $instances

instances

array(0) 

protected Config $_config

Default value:
array(0) 

protected array $_default_config

The default configuration for the memcached server

Default value:
array(0) 

protected string $_flags

Flags to use when storing values

Default value:
NULL

protected Memcache $_memcache

Memcache resource

Default value:
NULL

Methods

public delete_tag( string $tag ) (defined in Kohana_Cache_MemcacheTag)

Delete cache entries based on a tag

Parameters

  • string $tag required - Tag

Return Values

  • boolean

Source Code

public function delete_tag($tag)
{
    return $this->_memcache->tag_delete($tag);
}

public find( string $tag ) (defined in Kohana_Cache_MemcacheTag)

Find cache entries based on a tag

Parameters

  • string $tag required - Tag

Tags

Return Values

  • void

Source Code

public function find($tag)
{
    throw new Cache_Exception('Memcached-tags does not support finding by tag');
}

public set_with_tags( string $id , mixed $data [, integer $lifetime = NULL , array $tags = NULL ] ) (defined in Kohana_Cache_MemcacheTag)

Set a value based on an id with tags

Parameters

  • string $id required - Id
  • mixed $data required - Data
  • integer $lifetime = NULL - Lifetime [Optional]
  • array $tags = NULL - Tags [Optional]

Return Values

  • boolean

Source Code

public function set_with_tags($id, $data, $lifetime = null, array $tags = null)
{
    $id = $this->_sanitize_id($id);

    $result = $this->set($id, $data, $lifetime);

    if ($result and $tags) {
        foreach ($tags as $tag) {
            $this->_memcache->tag_add($tag, $id);
        }
    }

    return $result;
}

public _failed_request( string $hostname , integer $port ) (defined in Kohana_Cache_Memcache)

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.

Parameters

  • string $hostname required - $hostname
  • integer $port required - $port

Tags

  • Since - 3.0.8

Return Values

  • void|boolean

Source Code

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'],
                // Server is offline
                false, [$this, '_failed_request']
        );
    }
}

public decrement( string $id [, int $step = integer 1 ] ) (defined in Kohana_Cache_Memcache)

Decrements a given value by the step value supplied. Useful for shared counters and other persistent integer based tracking.

Parameters

  • string $id required - Id of cache entry to decrement
  • int $step = integer 1 - Step value to decrement by

Return Values

  • integer
  • boolean

Source Code

public function decrement($id, $step = 1)
{
    return $this->_memcache->decrement($id, $step);
}

public delete( string $id [, integer $timeout = integer 0 ] ) (defined in Kohana_Cache_Memcache)

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

Parameters

  • 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

Return Values

  • boolean

Source Code

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

public delete_all( ) (defined in Kohana_Cache_Memcache)

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

Return Values

  • boolean

Source Code

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

public get( string $id [, string $default = NULL ] ) (defined in Kohana_Cache_Memcache)

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

Parameters

  • string $id required - Id of cache to entry
  • string $default = NULL - Default value to return if cache miss

Tags

Return Values

  • mixed

Source Code

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

public increment( string $id [, int $step = integer 1 ] ) (defined in Kohana_Cache_Memcache)

Increments a given value by the step value supplied. Useful for shared counters and other persistent integer based tracking.

Parameters

  • string $id required - Id of cache entry to increment
  • int $step = integer 1 - Step value to increment by

Return Values

  • integer
  • boolean

Source Code

public function increment($id, $step = 1)
{
    return $this->_memcache->increment($id, $step);
}

public set( string $id , mixed $data [, integer $lifetime = integer 3600 ] ) (defined in Kohana_Cache_Memcache)

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
}

Parameters

  • 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

Return Values

  • boolean

Source Code

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

final public __clone( ) (defined in Kohana_Cache)

Overload the __clone() method to prevent cloning

Tags

Return Values

  • void

Source Code

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

public config( [ mixed $key = NULL , mixed $value = NULL ] ) (defined in Kohana_Cache)

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

Parameters

  • mixed $key = NULL - Key to set to array, either array or config path
  • mixed $value = NULL - Value to associate with key

Return Values

  • mixed

Source Code

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

public static instance( [ string $group = NULL ] ) (defined in Kohana_Cache)

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

Parameters

  • string $group = NULL - The name of the cache group to use [Optional]

Tags

Return Values

  • Cache

Source Code

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', [':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 __construct( array $config ) (defined in Kohana_Cache_MemcacheTag)

Constructs the memcache object

Parameters

  • array $config required - Configuration

Tags

Source Code

protected function __construct(array $config)
{
    parent::__construct($config);

    if (!method_exists($this->_memcache, 'tag_add')) {
        throw new Cache_Exception('Memcached-tags PHP plugin not present. Please see http://code.google.com/p/memcached-tags/ for more information');
    }
}

protected _sanitize_id( string $id ) (defined in Kohana_Cache)

Replaces troublesome characters with underscores.

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

Parameters

  • string $id required - Id of cache to sanitize

Return Values

  • string

Source Code

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