Magento 2 Documentation: Zend_Cache_Backend

Returns: void

Definition at line 120 of file Memcached.php.

     {
         if (!extension_loaded('memcache')) {
             Zend_Cache::throwException('The memcache extension must be loaded for using this backend !');
         }
         parent::__construct($options);
         if (isset($this->_options['servers'])) {
             $value= $this->_options['servers'];
             if (isset($value['host'])) {
                 // in this case, $value seems to be a simple associative array (one server only)
                 $value = array(0 => $value); // let's transform it into a classical array of associative arrays
             }
             $this->setOption('servers', $value);
         }
         $this->_memcache = new Memcache;
         foreach ($this->_options['servers'] as $server) {
             if (!array_key_exists('port', $server)) {
                 $server['port'] = self::DEFAULT_PORT;
             }
             if (!array_key_exists('persistent', $server)) {
                 $server['persistent'] = self::DEFAULT_PERSISTENT;
             }
             if (!array_key_exists('weight', $server)) {
                 $server['weight'] = self::DEFAULT_WEIGHT;
             }
             if (!array_key_exists('timeout', $server)) {
                 $server['timeout'] = self::DEFAULT_TIMEOUT;
             }
             if (!array_key_exists('retry_interval', $server)) {
                 $server['retry_interval'] = self::DEFAULT_RETRY_INTERVAL;
             }
             if (!array_key_exists('status', $server)) {
                 $server['status'] = self::DEFAULT_STATUS;
             }
             if (!array_key_exists('failure_callback', $server)) {
                 $server['failure_callback'] = self::DEFAULT_FAILURE_CALLBACK;
             }
             if ($this->_options['compatibility']) {
                 // No status for compatibility mode (#ZF-5887)
                 $this->_memcache->addServer($server['host'], $server['port'], $server['persistent'],
                                         $server['weight'], $server['timeout'],
                                         $server['retry_interval']);
             } else {
                 $this->_memcache->addServer($server['host'], $server['port'], $server['persistent'],
                                         $server['weight'], $server['timeout'],
                                         $server['retry_interval'],
                                         $server['status'], $server['failure_callback']);
             }
         }
     }

Member Function Documentation

◆ clean()

clean	(	$mode = `Zend_Cache::CLEANING_MODE_ALL`,
		$tags = `array()`
	)

Clean some cache records

Available modes are : 'all' (default) => remove all cache entries ($tags is not used) 'old' => unsupported 'matchingTag' => unsupported 'notMatchingTag' => unsupported 'matchingAnyTag' => unsupported

Parameters

string	$mode	Clean mode
array	$tags	Array of tags

Exceptions

Returns: boolean True if no problem

Definition at line 259 of file Memcached.php.

     {
         switch ($mode) {
             case Zend_Cache::CLEANING_MODE_ALL:
                 return $this->_memcache->flush();
                 break;
             case Zend_Cache::CLEANING_MODE_OLD:
                 $this->_log("Zend_Cache_Backend_Memcached::clean() : CLEANING_MODE_OLD is unsupported by the Memcached backend");
                 break;
             case Zend_Cache::CLEANING_MODE_MATCHING_TAG:
             case Zend_Cache::CLEANING_MODE_NOT_MATCHING_TAG:
             case Zend_Cache::CLEANING_MODE_MATCHING_ANY_TAG:
                 $this->_log(self::TAGS_UNSUPPORTED_BY_CLEAN_OF_MEMCACHED_BACKEND);
                 break;
                default:
                 Zend_Cache::throwException('Invalid mode for clean() method');
                    break;
         }
     }

◆ getCapabilities()

getCapabilities ( )

Return an associative array of capabilities (booleans) of the backend

The array must include these keys :

automatic_cleaning (is automating cleaning necessary)
tags (are tags supported)
expired_read (is it possible to read expired cache records (for doNotTestCacheValidity option for example))
priority does the backend deal with priority when saving
infinite_lifetime (is infinite lifetime can work with this backend)
get_list (is it possible to get the list of cache ids and the complete list of tags)

Returns: array associative of with capabilities

Definition at line 497 of file Memcached.php.

     {
         return array(
             'automatic_cleaning' => false,
             'tags' => false,
             'expired_read' => false,
             'priority' => false,
             'infinite_lifetime' => false,
             'get_list' => false
         );
     }

◆ getFillingPercentage()

getFillingPercentage ( )

Return the filling percentage of the backend storage

Exceptions

Returns: int integer between 0 and 100

Couchbase 1.x uses 'mem_used' instead of 'bytes'

See also: https://www.couchbase.com/issues/browse/MB-3466

Definition at line 380 of file Memcached.php.

     {
         $mems = $this->_memcache->getExtendedStats();
 
         $memSize = null;
         $memUsed = null;
         foreach ($mems as $key => $mem) {
             if ($mem === false) {
                 $this->_log('can\'t get stat from ' . $key);
                 continue;
             }
 
             $eachSize = $mem['limit_maxbytes'];
 
             $eachUsed = isset($mem['bytes']) ? $mem['bytes'] : $mem['mem_used'];
             if ($eachUsed > $eachSize) {
                 $eachUsed = $eachSize;
             }
 
             $memSize += $eachSize;
             $memUsed += $eachUsed;
         }
 
         if ($memSize === null || $memUsed === null) {
             Zend_Cache::throwException('Can\'t get filling percentage');
         }
 
         return ((int) (100. * ($memUsed / $memSize)));
     }

◆ getIds()

getIds ( )

Return an array of stored cache ids

Returns: array array of stored cache ids (string)

Definition at line 315 of file Memcached.php.

     {
         $this->_log("Zend_Cache_Backend_Memcached::save() : getting the list of cache ids is unsupported by the Memcache backend");
         return array();
     }

◆ getIdsMatchingAnyTags()

getIdsMatchingAnyTags ( $tags = array() )

Return an array of stored cache ids which match any given tags

In case of multiple tags, a logical AND is made between tags

Parameters

array $tags array of tags

Returns: array array of any matching cache ids (string)

Definition at line 368 of file Memcached.php.

     {
         $this->_log(self::TAGS_UNSUPPORTED_BY_SAVE_OF_MEMCACHED_BACKEND);
         return array();
     }

◆ getIdsMatchingTags()

getIdsMatchingTags ( $tags = array() )

Return an array of stored cache ids which match given tags

In case of multiple tags, a logical AND is made between tags

Parameters

array $tags array of tags

Returns: array array of matching cache ids (string)

Definition at line 340 of file Memcached.php.

     {
         $this->_log(self::TAGS_UNSUPPORTED_BY_SAVE_OF_MEMCACHED_BACKEND);
         return array();
     }

◆ getIdsNotMatchingTags()

getIdsNotMatchingTags ( $tags = array() )

Return an array of stored cache ids which don't match given tags

In case of multiple tags, a logical OR is made between tags

Parameters

array $tags array of tags

Returns: array array of not matching cache ids (string)

Definition at line 354 of file Memcached.php.

     {
         $this->_log(self::TAGS_UNSUPPORTED_BY_SAVE_OF_MEMCACHED_BACKEND);
         return array();
     }

◆ getMetadatas()

getMetadatas ( $id )

Return an array of metadatas for the given cache id

The array must include these keys :

expire : the expire timestamp
tags : a string array of tags
mtime : timestamp of last modification time

Parameters

string $id cache id

Returns: array array of metadatas (false if the cache id is not found)

Definition at line 425 of file Memcached.php.

     {
         $tmp = $this->_memcache->get($id);
         if (is_array($tmp)) {
             $data = $tmp[0];
             $mtime = $tmp[1];
             if (!isset($tmp[2])) {
                 // because this record is only with 1.7 release
                 // if old cache records are still there...
                 return false;
             }
             $lifetime = $tmp[2];
             return array(
                 'expire' => $mtime + $lifetime,
                 'tags' => array(),
                 'mtime' => $mtime
             );
         }
         return false;
     }

◆ getTags()

getTags ( )

Return an array of stored tags

Returns: array array of stored tags (string)

Definition at line 326 of file Memcached.php.

     {
         $this->_log(self::TAGS_UNSUPPORTED_BY_SAVE_OF_MEMCACHED_BACKEND);
         return array();
     }

◆ isAutomaticCleaningAvailable()

isAutomaticCleaningAvailable ( )

Return true if the automatic cleaning is available for the backend

Returns: boolean

Definition at line 284 of file Memcached.php.

     {
         return false;
     }

◆ load()

load	(	$id,
		$doNotTestCacheValidity = `false`
	)

Test if a cache is available for the given id and (if yes) return it (false else)

Parameters

string	$id	Cache id
boolean	$doNotTestCacheValidity	If set to true, the cache validity won't be tested

Returns: string|false cached datas

Definition at line 178 of file Memcached.php.

     {
         $tmp = $this->_memcache->get($id);
         if (is_array($tmp) && isset($tmp[0])) {
             return $tmp[0];
         }
         return false;
     }

◆ remove()

remove ( $id )

Remove a cache record

Parameters

string $id Cache id

Returns: boolean True if no problem

Definition at line 239 of file Memcached.php.

     {
         return $this->_memcache->delete($id, 0);
     }

◆ save()

save	(	$data,
		$id,
		$tags = `array()`,
		$specificLifetime = `false`
	)

Save some string datas into a cache record

Note : $data is always "string" (serialization is done by the core not by the backend)

Parameters

string	$data	Datas to cache
string	$id	Cache id
array	$tags	Array of strings, the cache record will be tagged by each string entry
int	$specificLifetime	If != false, set a specific lifetime for this cache record (null => infinite lifetime)

Returns: boolean True if no problem

Definition at line 214 of file Memcached.php.

     {
         $lifetime = $this->getLifetime($specificLifetime);
         if ($this->_options['compression']) {
             $flag = MEMCACHE_COMPRESSED;
         } else {
             $flag = 0;
         }
 
         // ZF-8856: using set because add needs a second request if item already exists
         $result = @$this->_memcache->set($id, array($data, time(), $lifetime), $flag, $lifetime);
 
         if (count($tags) > 0) {
             $this->_log(self::TAGS_UNSUPPORTED_BY_SAVE_OF_MEMCACHED_BACKEND);
         }
 
         return $result;
     }

◆ setDirectives()

setDirectives ( $directives )

Set the frontend directives

Parameters

array $directives Assoc of directives

Exceptions

Returns: void

Definition at line 296 of file Memcached.php.

     {
         parent::setDirectives($directives);
         $lifetime = $this->getLifetime(false);
         if ($lifetime > 2592000) {
             // #ZF-3490 : For the memcached backend, there is a lifetime limit of 30 days (2592000 seconds)
             $this->_log('memcached backend has a limit of 30 days (2592000 seconds) for the lifetime');
         }
         if ($lifetime === null) {
             // #ZF-4614 : we tranform null to zero to get the maximal lifetime
             parent::setDirectives(array('lifetime' => 0));
         }
     }

◆ test()

test ( $id )

Test if a cache is available or not (for the given id)

Parameters

string $id Cache id

Returns: mixed|false (a cache is not available) or "last modified" timestamp (int) of the available cache record

Definition at line 193 of file Memcached.php.

     {
         $tmp = $this->_memcache->get($id);
         if (is_array($tmp)) {
             return $tmp[1];
         }
         return false;
     }

◆ touch()

touch	(	$id,
		$extraLifetime
	)

Give (if possible) an extra lifetime to the given cache id

Parameters

string	$id	cache id
int	$extraLifetime

Returns: boolean true if ok