258 lines
8.2 KiB
PHP
258 lines
8.2 KiB
PHP
<?php
|
|
/**
|
|
* CRedisCache class file
|
|
*
|
|
* @author Carsten Brandt <mail@cebe.cc>
|
|
* @link http://www.yiiframework.com/
|
|
* @copyright 2008-2013 Yii Software LLC
|
|
* @license http://www.yiiframework.com/license/
|
|
*/
|
|
|
|
/**
|
|
* CRedisCache implements a cache application component based on {@link http://redis.io/ redis}.
|
|
*
|
|
* CRedisCache needs to be configured with {@link hostname}, {@link port} and {@link database} of the server
|
|
* to connect to. By default CRedisCache assumes there is a redis server running on localhost at
|
|
* port 6379 and uses the database number 0.
|
|
*
|
|
* CRedisCache also supports {@link http://redis.io/commands/auth the AUTH command} of redis.
|
|
* When the server needs authentication, you can set the {@link password} property to
|
|
* authenticate with the server after connect.
|
|
*
|
|
* See {@link CCache} manual for common cache operations that are supported by CRedisCache.
|
|
*
|
|
* To use CRedisCache as the cache application component, configure the application as follows,
|
|
* <pre>
|
|
* array(
|
|
* 'components'=>array(
|
|
* 'cache'=>array(
|
|
* 'class'=>'CRedisCache',
|
|
* 'hostname'=>'localhost',
|
|
* 'port'=>6379,
|
|
* 'database'=>0,
|
|
* ),
|
|
* ),
|
|
* )
|
|
* </pre>
|
|
*
|
|
* The minimum required redis version is 2.0.0.
|
|
*
|
|
* @author Carsten Brandt <mail@cebe.cc>
|
|
* @package system.caching
|
|
* @since 1.1.14
|
|
*/
|
|
class CRedisCache extends CCache
|
|
{
|
|
/**
|
|
* @var string hostname to use for connecting to the redis server. Defaults to 'localhost'.
|
|
*/
|
|
public $hostname='localhost';
|
|
/**
|
|
* @var int the port to use for connecting to the redis server. Default port is 6379.
|
|
*/
|
|
public $port=6379;
|
|
/**
|
|
* @var string the password to use to authenticate with the redis server. If not set, no AUTH command will be sent.
|
|
*/
|
|
public $password;
|
|
/**
|
|
* @var int the redis database to use. This is an integer value starting from 0. Defaults to 0.
|
|
*/
|
|
public $database=0;
|
|
/**
|
|
* @var float timeout to use for connection to redis. If not set the timeout set in php.ini will be used: ini_get("default_socket_timeout")
|
|
*/
|
|
public $timeout=null;
|
|
/**
|
|
* @var resource redis socket connection
|
|
*/
|
|
private $_socket;
|
|
|
|
/**
|
|
* Establishes a connection to the redis server.
|
|
* It does nothing if the connection has already been established.
|
|
* @throws CException if connecting fails
|
|
*/
|
|
protected function connect()
|
|
{
|
|
$this->_socket=@stream_socket_client(
|
|
$this->hostname.':'.$this->port,
|
|
$errorNumber,
|
|
$errorDescription,
|
|
$this->timeout ? $this->timeout : ini_get("default_socket_timeout")
|
|
);
|
|
if ($this->_socket)
|
|
{
|
|
if($this->password!==null)
|
|
$this->executeCommand('AUTH',array($this->password));
|
|
$this->executeCommand('SELECT',array($this->database));
|
|
}
|
|
else
|
|
throw new CException('Failed to connect to redis: '.$errorDescription,(int)$errorNumber);
|
|
}
|
|
|
|
/**
|
|
* Executes a redis command.
|
|
* For a list of available commands and their parameters see {@link http://redis.io/commands}.
|
|
*
|
|
* @param string $name the name of the command
|
|
* @param array $params list of parameters for the command
|
|
* @return array|bool|null|string Dependend on the executed command this method
|
|
* will return different data types:
|
|
* <ul>
|
|
* <li><code>true</code> for commands that return "status reply".</li>
|
|
* <li><code>string</code> for commands that return "integer reply"
|
|
* as the value is in the range of a signed 64 bit integer.</li>
|
|
* <li><code>string</code> or <code>null</code> for commands that return "bulk reply".</li>
|
|
* <li><code>array</code> for commands that return "Multi-bulk replies".</li>
|
|
* </ul>
|
|
* See {@link http://redis.io/topics/protocol redis protocol description}
|
|
* for details on the mentioned reply types.
|
|
* @trows CException for commands that return {@link http://redis.io/topics/protocol#error-reply error reply}.
|
|
*/
|
|
public function executeCommand($name,$params=array())
|
|
{
|
|
if($this->_socket===null)
|
|
$this->connect();
|
|
|
|
array_unshift($params,$name);
|
|
$command='*'.count($params)."\r\n";
|
|
foreach($params as $arg)
|
|
$command.='$'.strlen($arg)."\r\n".$arg."\r\n";
|
|
|
|
fwrite($this->_socket,$command);
|
|
|
|
return $this->parseResponse(implode(' ',$params));
|
|
}
|
|
|
|
/**
|
|
* Reads the result from socket and parses it
|
|
* @return array|bool|null|string
|
|
* @throws CException socket or data problems
|
|
*/
|
|
private function parseResponse()
|
|
{
|
|
if(($line=fgets($this->_socket))===false)
|
|
throw new CException('Failed reading data from redis connection socket.');
|
|
$type=$line[0];
|
|
$line=substr($line,1,-2);
|
|
switch($type)
|
|
{
|
|
case '+': // Status reply
|
|
return true;
|
|
case '-': // Error reply
|
|
throw new CException('Redis error: '.$line);
|
|
case ':': // Integer reply
|
|
// no cast to int as it is in the range of a signed 64 bit integer
|
|
return $line;
|
|
case '$': // Bulk replies
|
|
if($line=='-1')
|
|
return null;
|
|
$length=$line+2;
|
|
$data='';
|
|
while($length>0)
|
|
{
|
|
if(($block=fread($this->_socket,$length))===false)
|
|
throw new CException('Failed reading data from redis connection socket.');
|
|
$data.=$block;
|
|
$length-=(function_exists('mb_strlen') ? mb_strlen($block,'8bit') : strlen($block));
|
|
}
|
|
return substr($data,0,-2);
|
|
case '*': // Multi-bulk replies
|
|
$count=(int)$line;
|
|
$data=array();
|
|
for($i=0;$i<$count;$i++)
|
|
$data[]=$this->parseResponse();
|
|
return $data;
|
|
default:
|
|
throw new CException('Unable to parse data received from redis.');
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Retrieves a value from cache with a specified key.
|
|
* This is the implementation of the method declared in the parent class.
|
|
* @param string $key a unique key identifying the cached value
|
|
* @return string|boolean the value stored in cache, false if the value is not in the cache or expired.
|
|
*/
|
|
protected function getValue($key)
|
|
{
|
|
return $this->executeCommand('GET',array($key));
|
|
}
|
|
|
|
/**
|
|
* Retrieves multiple values from cache with the specified keys.
|
|
* @param array $keys a list of keys identifying the cached values
|
|
* @return array a list of cached values indexed by the keys
|
|
*/
|
|
protected function getValues($keys)
|
|
{
|
|
$response=$this->executeCommand('MGET',$keys);
|
|
$result=array();
|
|
$i=0;
|
|
foreach($keys as $key)
|
|
$result[$key]=$response[$i++];
|
|
return $result;
|
|
}
|
|
|
|
/**
|
|
* Stores a value identified by a key in cache.
|
|
* This is the implementation of the method declared in the parent class.
|
|
*
|
|
* @param string $key the key identifying the value to be cached
|
|
* @param string $value the value to be cached
|
|
* @param integer $expire the number of seconds in which the cached value will expire. 0 means never expire.
|
|
* @return boolean true if the value is successfully stored into cache, false otherwise
|
|
*/
|
|
protected function setValue($key,$value,$expire)
|
|
{
|
|
if ($expire==0)
|
|
return (bool)$this->executeCommand('SET',array($key,$value));
|
|
return (bool)$this->executeCommand('SETEX',array($key,$expire,$value));
|
|
}
|
|
|
|
/**
|
|
* Stores a value identified by a key into cache if the cache does not contain this key.
|
|
* This is the implementation of the method declared in the parent class.
|
|
*
|
|
* @param string $key the key identifying the value to be cached
|
|
* @param string $value the value to be cached
|
|
* @param integer $expire the number of seconds in which the cached value will expire. 0 means never expire.
|
|
* @return boolean true if the value is successfully stored into cache, false otherwise
|
|
*/
|
|
protected function addValue($key,$value,$expire)
|
|
{
|
|
if ($expire == 0)
|
|
return (bool)$this->executeCommand('SETNX',array($key,$value));
|
|
|
|
if($this->executeCommand('SETNX',array($key,$value)))
|
|
{
|
|
$this->executeCommand('EXPIRE',array($key,$expire));
|
|
return true;
|
|
}
|
|
else
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Deletes a value with the specified key from cache
|
|
* This is the implementation of the method declared in the parent class.
|
|
* @param string $key the key of the value to be deleted
|
|
* @return boolean if no error happens during deletion
|
|
*/
|
|
protected function deleteValue($key)
|
|
{
|
|
return (bool)$this->executeCommand('DEL',array($key));
|
|
}
|
|
|
|
/**
|
|
* Deletes all values from cache.
|
|
* This is the implementation of the method declared in the parent class.
|
|
* @return boolean whether the flush operation was successful.
|
|
*/
|
|
protected function flushValues()
|
|
{
|
|
return $this->executeCommand('FLUSHDB');
|
|
}
|
|
}
|