RedisCache.php 7.25 KB
Newer Older
1 2 3 4 5 6 7 8 9
<?php
/**
 * @link http://www.yiiframework.com/
 * @copyright Copyright (c) 2008 Yii Software LLC
 * @license http://www.yiiframework.com/license/
 */

namespace yii\caching;

10
use yii\redis\Connection;
11 12

/**
Carsten Brandt committed
13
 * RedisCache implements a cache application component based on [redis](http://redis.io/) version 2.6 or higher.
14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29
 *
 * RedisCache needs to be configured with [[hostname]], [[port]] and [[database]] of the server
 * to connect to. By default RedisCache assumes there is a redis server running on localhost at
 * port 6379 and uses the database number 0.
 *
 * RedisCache also supports [the AUTH command](http://redis.io/commands/auth) of redis.
 * When the server needs authentication, you can set the [[password]] property to
 * authenticate with the server after connect.
 *
 * See [[Cache]] manual for common cache operations that RedisCache supports.
 * Unlike the [[CCache]], RedisCache allows the expire parameter of
 * [[set]] and [[add]] to be a floating point number, so you may specify the time in milliseconds.
 *
 * To use RedisCache as the cache application component, configure the application as follows,
 *
 * ~~~
Alexander Makarov committed
30 31 32 33 34 35 36 37 38 39
 * [
 *     'components' => [
 *         'cache' => [
 *             'class' => 'RedisCache',
 *             'hostname' => 'localhost',
 *             'port' => 6379,
 *             'database' => 0,
 *         ],
 *     ],
 * ]
40 41
 * ~~~
 *
42
 * @property Connection $connection The redis connection object. This property is read-only.
43
 *
44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73
 * @author Carsten Brandt <mail@cebe.cc>
 * @since 2.0
 */
class RedisCache extends Cache
{
	/**
	 * @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 $connectionTimeout = null;
	/**
	 * @var float timeout to use for redis socket when reading and writing data. If not set the php default value will be used.
	 */
	public $dataTimeout = null;
	/**
74
	 * @var Connection the redis connection
75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90
	 */
	private $_connection;


	/**
	 * Initializes the cache component by establishing a connection to the redis server.
	 */
	public function init()
	{
		parent::init();
		$this->getConnection();
	}

	/**
	 * Returns the redis connection object.
	 * Establishes a connection to the redis server if it does not already exists.
91
	 * @return Connection the redis connection object.
92 93 94 95
	 */
	public function getConnection()
	{
		if ($this->_connection === null) {
Alexander Makarov committed
96
			$this->_connection = new Connection([
97 98 99 100
				'dsn' => 'redis://' . $this->hostname . ':' . $this->port . '/' . $this->database,
				'password' => $this->password,
				'connectionTimeout' => $this->connectionTimeout,
				'dataTimeout' => $this->dataTimeout,
Alexander Makarov committed
101
			]);
102 103 104 105
		}
		return $this->_connection;
	}

106 107 108 109 110 111 112 113 114 115 116 117
	/**
	 * Checks whether a specified key exists in the cache.
	 * This can be faster than getting the value from the cache if the data is big.
	 * Note that this method does not check whether the dependency associated
	 * with the cached data, if there is any, has changed. So a call to [[get]]
	 * may return false while exists returns true.
	 * @param mixed $key a key identifying the cached value. This can be a simple string or
	 * a complex data structure consisting of factors representing the key.
	 * @return boolean true if a value exists in cache, false if the value is not in the cache or expired.
	 */
	public function exists($key)
	{
Alexander Makarov committed
118
		return (bool) $this->_connection->executeCommand('EXISTS', [$this->buildKey($key)]);
119 120
	}

121 122 123 124 125 126 127 128
	/**
	 * 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)
	{
Alexander Makarov committed
129
		return $this->_connection->executeCommand('GET', [$key]);
130 131 132 133 134 135 136 137 138 139
	}

	/**
	 * 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->_connection->executeCommand('MGET', $keys);
Alexander Makarov committed
140
		$result = [];
141
		$i = 0;
142
		foreach ($keys as $key) {
143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160
			$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 float $expire the number of seconds in which the cached value will expire. 0 means never expire.
	 * This can be a floating point number to specify the time in milliseconds.
	 * @return boolean true if the value is successfully stored into cache, false otherwise
	 */
	protected function setValue($key,$value,$expire)
	{
		if ($expire == 0) {
Alexander Makarov committed
161
			return (bool) $this->_connection->executeCommand('SET', [$key, $value]);
162 163
		} else {
			$expire = (int) ($expire * 1000);
Alexander Makarov committed
164
			return (bool) $this->_connection->executeCommand('PSETEX', [$key, $expire, $value]);
165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180
		}
	}

	/**
	 * 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 float $expire the number of seconds in which the cached value will expire. 0 means never expire.
	 * This can be a floating point number to specify the time in milliseconds.
	 * @return boolean true if the value is successfully stored into cache, false otherwise
	 */
	protected function addValue($key,$value,$expire)
	{
		if ($expire == 0) {
Alexander Makarov committed
181
			return (bool) $this->_connection->executeCommand('SETNX', [$key, $value]);
182 183 184 185
		} else {
			// TODO consider requiring redis version >= 2.6.12 that supports this in one command
			$expire = (int) ($expire * 1000);
			$this->_connection->executeCommand('MULTI');
Alexander Makarov committed
186 187
			$this->_connection->executeCommand('SETNX', [$key, $value]);
			$this->_connection->executeCommand('PEXPIRE', [$key, $expire]);
188 189 190 191 192 193 194 195 196 197 198 199 200
			$response = $this->_connection->executeCommand('EXEC');
			return (bool) $response[0];
		}
	}

	/**
	 * 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)
	{
Alexander Makarov committed
201
		return (bool) $this->_connection->executeCommand('DEL', [$key]);
202 203 204 205 206 207 208 209 210 211 212 213
	}

	/**
	 * 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->_connection->executeCommand('FLUSHDB');
	}
}