460 lines
15 KiB
PHP
460 lines
15 KiB
PHP
<?php
|
|
/**
|
|
* @see Zend_Cache_Backend
|
|
*/
|
|
|
|
/**
|
|
* @see Zend_Cache_Backend_ExtendedInterface
|
|
*/
|
|
|
|
/**
|
|
* @author Olivier Bregeras (Stunti) (olivier.bregeras@gmail.com)
|
|
* @category Stunti
|
|
* @package Stunti_Cache
|
|
* @subpackage Stunti_Cache_Backend
|
|
* @copyright Copyright (c) 2009 Stunti. (http://www.stunti.org)
|
|
* @license http://stunti.org/license/new-bsd New BSD License
|
|
*/
|
|
class Zeed_Cache_Backend_Mongo extends Zend_Cache_Backend implements Zend_Cache_Backend_ExtendedInterface
|
|
{
|
|
|
|
const DEFAULT_HOST = '127.0.0.1';
|
|
const DEFAULT_PORT = 27017;
|
|
const DEFAULT_PERSISTENT = true;
|
|
const DEFAULT_DBNAME = 'Db_Cache';
|
|
const DEFAULT_COLLECTION = 'C_Cache';
|
|
|
|
protected $_conn;
|
|
protected $_db;
|
|
protected $_collection;
|
|
|
|
|
|
/**
|
|
* Available options
|
|
*
|
|
* =====> (array) servers :
|
|
* an array of mongodb server ; each mongodb server is described by an associative array :
|
|
* 'host' => (string) : the name of the mongodb server
|
|
* 'port' => (int) : the port of the mongodb server
|
|
* 'persistent' => (bool) : use or not persistent connections to this mongodb server
|
|
* 'collection' => (string) : name of the collection to use
|
|
* 'dbname' => (string) : name of the database to use
|
|
*
|
|
* @var array available options
|
|
*/
|
|
protected $_options = array(
|
|
'host' => self::DEFAULT_HOST,
|
|
'port' => self::DEFAULT_PORT,
|
|
'persistent' => self::DEFAULT_PERSISTENT,
|
|
'collection' => self::DEFAULT_COLLECTION,
|
|
'dbname' => self::DEFAULT_DBNAME,
|
|
);
|
|
|
|
/**
|
|
* @return void
|
|
*/
|
|
public function __construct($options)
|
|
{
|
|
if (!extension_loaded('mongo')) {
|
|
Zend_Cache::throwException('The MongoDB extension must be loaded for using this backend !');
|
|
}
|
|
parent::__construct($options);
|
|
|
|
// Merge the options passed in; overridding any default options
|
|
$this->_options = array_merge($this->_options, $options);
|
|
|
|
$this->_conn = new Mongo($this->_options['host'], $this->_options['port'], $this->_options['persistent']);
|
|
$this->_db = $this->_conn->selectDB($this->_options['dbname']);
|
|
$this->_collection = $this->_db->selectCollection($this->_options['collection']);
|
|
}
|
|
|
|
/**
|
|
* Expires a record (mostly used for testing purposes)
|
|
* @param string $id
|
|
* @return void
|
|
*/
|
|
public function ___expire($id)
|
|
{
|
|
$cursor = $this->get($id);
|
|
if ($tmp = $cursor->getNext()) {
|
|
$tmp['l'] = -10;
|
|
$this->_collection->save($tmp);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Test if a cache is available for the given id and (if yes) return it (false else)
|
|
*
|
|
* @param string $id Cache id
|
|
* @param boolean $doNotTestCacheValidity If set to true, the cache validity won't be tested
|
|
* @return string|false cached datas
|
|
*/
|
|
public function load($id, $doNotTestCacheValidity = false)
|
|
{
|
|
$cursor = $this->get($id);
|
|
if ($tmp = $cursor->getNext()) {
|
|
if ($doNotTestCacheValidity || !$doNotTestCacheValidity && ($tmp['created_at'] + $tmp['l'])>=time()) {
|
|
return $tmp['d'];
|
|
}
|
|
return false;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Test if a cache is available or not (for the given id)
|
|
*
|
|
* @param string $id Cache id
|
|
* @return mixed|false (a cache is not available) or "last modified" timestamp (int) of the available cache record
|
|
*/
|
|
public function test($id)
|
|
{
|
|
$cursor = $this->get($id);
|
|
if ($tmp = $cursor->getNext()) {
|
|
return $tmp['created_at'];
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Save some string datas into a cache record
|
|
*
|
|
* Note : $data is always "string" (serialization is done by the
|
|
* core not by the backend)
|
|
*
|
|
* @param string $data Datas to cache
|
|
* @param string $id Cache id
|
|
* @param array $tags Array of strings, the cache record will be tagged by each string entry
|
|
* @param int $specificLifetime If != false, set a specific lifetime for this cache record (null => infinite lifetime)
|
|
* @return boolean True if no problem
|
|
*/
|
|
public function save($data, $id, $tags = array(), $specificLifetime = false)
|
|
{
|
|
$lifetime = $this->getLifetime($specificLifetime);
|
|
$flag = 0;
|
|
|
|
// #ZF-5702 : we try add() first becase set() seems to be slower
|
|
$result = $this->set($id, $data, $lifetime,$tags);
|
|
|
|
return $result;
|
|
}
|
|
|
|
/**
|
|
* Remove a cache record
|
|
*
|
|
* @param string $id Cache id
|
|
* @return boolean True if no problem
|
|
*/
|
|
public function remove($id)
|
|
{
|
|
return $this->_collection->remove(array('_id' => $id));
|
|
}
|
|
|
|
/**
|
|
* Clean some cache records (protected method used for recursive stuff)
|
|
*
|
|
* Available modes are :
|
|
* Zend_Cache::CLEANING_MODE_ALL (default) => remove all cache entries ($tags is not used)
|
|
* Zend_Cache::CLEANING_MODE_OLD => remove too old cache entries ($tags is not used)
|
|
* Zend_Cache::CLEANING_MODE_MATCHING_TAG => remove cache entries matching all given tags
|
|
* ($tags can be an array of strings or a single string)
|
|
* Zend_Cache::CLEANING_MODE_NOT_MATCHING_TAG => remove cache entries not {matching one of the given tags}
|
|
* ($tags can be an array of strings or a single string)
|
|
* Zend_Cache::CLEANING_MODE_MATCHING_ANY_TAG => remove cache entries matching any given tags
|
|
* ($tags can be an array of strings or a single string)
|
|
*
|
|
* @param string $dir Directory to clean
|
|
* @param string $mode Clean mode
|
|
* @param array $tags Array of tags
|
|
* @throws Zend_Cache_Exception
|
|
* @return boolean True if no problem
|
|
*/
|
|
public function clean($mode = Zend_Cache::CLEANING_MODE_ALL, $tags = array())
|
|
{
|
|
switch ($mode) {
|
|
case Zend_Cache::CLEANING_MODE_ALL:
|
|
return $this->_collection->remove();
|
|
break;
|
|
case Zend_Cache::CLEANING_MODE_OLD:
|
|
//$res = $this->_instance->findOneCond(array('$where' => new MongoCode('function() { return (this.l + this.created_at) < '.(time()-1).'; }')));
|
|
//var_dump($res);exit;
|
|
return $this->_collection->remove(array('$where' => new MongoCode('function() { return (this.l + this.created_at) < '.(time()-1).'; }')));
|
|
break;
|
|
case Zend_Cache::CLEANING_MODE_MATCHING_TAG:
|
|
return $this->_collection->remove(array( 't' => array( '$all' => $tags ) ));
|
|
break;
|
|
case Zend_Cache::CLEANING_MODE_NOT_MATCHING_TAG:
|
|
return $this->_collection->remove(array( 't' => array( '$nin' => $tags ) ));
|
|
break;
|
|
case Zend_Cache::CLEANING_MODE_MATCHING_ANY_TAG:
|
|
//find all tags and remove them
|
|
//$this->_log(self::TAGS_UNSUPPORTED_BY_CLEAN_OF_MEMCACHED_BACKEND);
|
|
return $this->_collection->remove(array( 't' => array( '$in' => $tags ) ));
|
|
break;
|
|
default:
|
|
Zend_Cache::throwException('Invalid mode for clean() method');
|
|
break;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Return true if the automatic cleaning is available for the backend
|
|
*
|
|
* @return boolean
|
|
*/
|
|
public function isAutomaticCleaningAvailable()
|
|
{
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Set the frontend directives
|
|
*
|
|
* @param array $directives Assoc of directives
|
|
* @throws Zend_Cache_Exception
|
|
* @return void
|
|
*/
|
|
public function setDirectives($directives)
|
|
{
|
|
parent::setDirectives($directives);
|
|
$lifetime = $this->getLifetime(false);
|
|
if ($lifetime === null) {
|
|
// #ZF-4614 : we tranform null to zero to get the maximal lifetime
|
|
parent::setDirectives(array('lifetime' => 0));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Return an array of stored cache ids
|
|
*
|
|
* @return array array of stored cache ids (string)
|
|
*/
|
|
public function getIds() {
|
|
$cursor = $this->_collection->find();
|
|
$ret = array();
|
|
while ($tmp = $cursor->getNext()) {
|
|
$ret[] = $tmp['_id'];
|
|
}
|
|
return $ret;
|
|
}
|
|
|
|
/**
|
|
* Return an array of stored tags
|
|
*
|
|
* @return array array of stored tags (string)
|
|
*/
|
|
public function getTags() {
|
|
//might have to use map reduce for that (example on Mongodb doc)
|
|
|
|
$cmd['mapreduce'] = $this->_options['collection'];
|
|
//$cmd['verbose'] = true;
|
|
$cmd['map'] = 'function(){
|
|
this.t.forEach(
|
|
function(z){
|
|
emit( z , { count : 1 } );
|
|
}
|
|
);
|
|
};';
|
|
$cmd['reduce'] = 'function( key , values ){
|
|
var total = 0;
|
|
for ( var i=0; i<values.length; i++ )
|
|
total += values[i].count;
|
|
return { count : total };
|
|
};
|
|
';
|
|
|
|
$res2 = $this->_db->command($cmd);
|
|
$res3 = $this->_db->selectCollection($res2['result'])->find();
|
|
|
|
$res = array();
|
|
foreach ($res3 as $key => $val) {
|
|
$res[] = $key;
|
|
}
|
|
|
|
$this->_db->dropCollection($res2['result']);
|
|
|
|
return $res;
|
|
}
|
|
|
|
public function drop()
|
|
{
|
|
return $this->_collection->drop();
|
|
}
|
|
|
|
/**
|
|
* Return an array of stored cache ids which match given tags
|
|
*
|
|
* In case of multiple tags, a logical AND is made between tags
|
|
*
|
|
* @param array $tags array of tags
|
|
* @return array array of matching cache ids (string)
|
|
*/
|
|
public function getIdsMatchingTags($tags = array()) {
|
|
$cursor = $this->_collection->find(array( 't' => array( '$all' => $tags )));
|
|
$ret = array();
|
|
while ($tmp = $cursor->getNext()) {
|
|
$ret[] = $tmp['_id'];
|
|
}
|
|
|
|
return $ret;
|
|
}
|
|
|
|
/**
|
|
* 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
|
|
*
|
|
* @param array $tags array of tags
|
|
* @return array array of not matching cache ids (string)
|
|
*/
|
|
public function getIdsNotMatchingTags($tags = array()) {
|
|
$cursor = $this->_collection->find(array( 't' => array( '$nin' => $tags ) ));
|
|
$ret = array();
|
|
|
|
while ($tmp = $cursor->getNext()) {
|
|
$ret[] = $tmp['_id'];
|
|
}
|
|
|
|
return $ret;
|
|
}
|
|
|
|
/**
|
|
* Return an array of stored cache ids which match any given tags
|
|
*
|
|
* In case of multiple tags, a logical AND is made between tags
|
|
*
|
|
* @param array $tags array of tags
|
|
* @return array array of any matching cache ids (string)
|
|
*/
|
|
public function getIdsMatchingAnyTags($tags = array()) {
|
|
$res = $this->_collection->find(array( 't' => array( '$in' => $tags ) ));
|
|
|
|
$ret = array();
|
|
while ($tmp = $cursor->getNext()) {
|
|
$ret[] = $tmp['_id'];
|
|
}
|
|
|
|
return $ret;
|
|
}
|
|
|
|
/**
|
|
* No way to find the remaining space right now. So retrun 0.
|
|
*
|
|
* @throws Zend_Cache_Exception
|
|
* @return int integer between 0 and 100
|
|
*/
|
|
public function getFillingPercentage() {
|
|
return 1;
|
|
}
|
|
|
|
/**
|
|
* 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
|
|
*
|
|
* @param string $id cache id
|
|
* @return array array of metadatas (false if the cache id is not found)
|
|
*/
|
|
public function getMetadatas($id)
|
|
{
|
|
$cursor = $this->get($id);
|
|
|
|
if ($tmp = $cursor->getNext()) {
|
|
$data = $tmp['d'];
|
|
$mtime = $tmp['created_at'];
|
|
$lifetime = $tmp['l'];
|
|
return array(
|
|
'expire' => $mtime + $lifetime,
|
|
'tags' => $tmp['t'],
|
|
'mtime' => $mtime
|
|
);
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Give (if possible) an extra lifetime to the given cache id
|
|
*
|
|
* @param string $id cache id
|
|
* @param int $extraLifetime
|
|
* @return boolean true if ok
|
|
*/
|
|
public function touch($id, $extraLifetime)
|
|
{
|
|
$cursor = $this->get($id);
|
|
if ($tmp = $cursor->getNext()) {
|
|
$data = $tmp['d'];
|
|
$mtime = $tmp['created_at'];
|
|
$lifetime = $tmp['l'];
|
|
$tags = $tmp['t'];
|
|
$newLifetime = $lifetime - (time() - $mtime) + $extraLifetime;
|
|
if ($newLifetime <=0) {
|
|
return false;
|
|
}
|
|
|
|
// #ZF-5702 : we try replace() first becase set() seems to be slower
|
|
$result = $this->set($id, $data, $newLifetime,$tags);
|
|
return $result;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* 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)
|
|
*
|
|
* @return array associative of with capabilities
|
|
*/
|
|
public function getCapabilities()
|
|
{
|
|
return array(
|
|
'automatic_cleaning' => true,
|
|
'tags' => true,
|
|
'expired_read' => true,
|
|
'priority' => false,
|
|
'infinite_lifetime' => true,
|
|
'get_list' => true
|
|
);
|
|
}
|
|
|
|
/**
|
|
* @param int $id
|
|
* @param array $data
|
|
* @param int $lifetime
|
|
* @param mixed $tags
|
|
* @return boolean
|
|
*/
|
|
function set($id, $data, $lifetime, $tags)
|
|
{
|
|
return $this->_collection->save(array('_id' => $id,
|
|
'd' => $data,
|
|
'created_at' => time(),
|
|
'l' => $lifetime,
|
|
't' => $tags
|
|
));
|
|
|
|
}
|
|
|
|
/**
|
|
* @param int $id
|
|
* @return array|false
|
|
*/
|
|
function get($id)
|
|
{
|
|
return $this->_collection->find(array('_id' => $id));
|
|
|
|
}
|
|
}
|