1 <?php
  2 /**
  3  * @package     Joomla.Platform
  4  * @subpackage  Cache
  5  *
  6  * @copyright   Copyright (C) 2005 - 2017 Open Source Matters, Inc. All rights reserved.
  7  * @license     GNU General Public License version 2 or later; see LICENSE
  8  */
  9 
 10 defined('JPATH_PLATFORM') or die;
 11 
 12 /**
 13  * Redis cache storage handler for PECL
 14  *
 15  * @since  3.4
 16  */
 17 class JCacheStorageRedis extends JCacheStorage
 18 {
 19     /**
 20      * Redis connection object
 21      *
 22      * @var    Redis
 23      * @since  3.4
 24      */
 25     protected static $_redis = null;
 26 
 27     /**
 28      * Persistent session flag
 29      *
 30      * @var    boolean
 31      * @since  3.4
 32      */
 33     protected $_persistent = false;
 34 
 35     /**
 36      * Constructor
 37      *
 38      * @param   array  $options  Optional parameters.
 39      *
 40      * @since   3.4
 41      */
 42     public function __construct($options = array())
 43     {
 44         parent::__construct($options);
 45 
 46         if (static::$_redis === null)
 47         {
 48             $this->getConnection();
 49         }
 50     }
 51 
 52     /**
 53      * Create the Redis connection
 54      *
 55      * @return  Redis|boolean  Redis connection object on success, boolean on failure
 56      *
 57      * @since   3.4
 58      * @note    As of 4.0 this method will throw a JCacheExceptionConnecting object on connection failure
 59      */
 60     protected function getConnection()
 61     {
 62         if (static::isSupported() == false)
 63         {
 64             return false;
 65         }
 66 
 67         $app = JFactory::getApplication();
 68 
 69         $this->_persistent = $app->get('redis_persist', true);
 70 
 71         $server = array(
 72             'host' => $app->get('redis_server_host', 'localhost'),
 73             'port' => $app->get('redis_server_port', 6379),
 74             'auth' => $app->get('redis_server_auth', null),
 75             'db'   => (int) $app->get('redis_server_db', null),
 76         );
 77 
 78         static::$_redis = new Redis;
 79 
 80         if ($this->_persistent)
 81         {
 82             try
 83             {
 84                 $connection = static::$_redis->pconnect($server['host'], $server['port']);
 85                 $auth       = (!empty($server['auth'])) ? static::$_redis->auth($server['auth']) : true;
 86             }
 87             catch (RedisException $e)
 88             {
 89                 JLog::add($e->getMessage(), JLog::DEBUG);
 90             }
 91         }
 92         else
 93         {
 94             try
 95             {
 96                 $connection = static::$_redis->connect($server['host'], $server['port']);
 97                 $auth       = (!empty($server['auth'])) ? static::$_redis->auth($server['auth']) : true;
 98             }
 99             catch (RedisException $e)
100             {
101                 JLog::add($e->getMessage(), JLog::DEBUG);
102             }
103         }
104 
105         if ($connection == false)
106         {
107             static::$_redis = null;
108 
109             if ($app->isClient('administrator'))
110             {
111                 JError::raiseWarning(500, 'Redis connection failed');
112             }
113 
114             return false;
115         }
116 
117         if ($auth == false)
118         {
119             if ($app->isClient('administrator'))
120             {
121                 JError::raiseWarning(500, 'Redis authentication failed');
122             }
123 
124             return false;
125         }
126 
127         $select = static::$_redis->select($server['db']);
128 
129         if ($select == false)
130         {
131             static::$_redis = null;
132 
133             if ($app->isClient('administrator'))
134             {
135                 JError::raiseWarning(500, 'Redis failed to select database');
136             }
137 
138             return false;
139         }
140 
141         try
142         {
143             static::$_redis->ping();
144         }
145         catch (RedisException $e)
146         {
147             static::$_redis = null;
148 
149             if ($app->isClient('administrator'))
150             {
151                 JError::raiseWarning(500, 'Redis ping failed');
152             }
153 
154             return false;
155         }
156 
157         return static::$_redis;
158     }
159 
160     /**
161      * Check if the cache contains data stored by ID and group
162      *
163      * @param   string  $id     The cache data ID
164      * @param   string  $group  The cache data group
165      *
166      * @return  boolean
167      *
168      * @since   3.7.0
169      */
170     public function contains($id, $group)
171     {
172         if (static::isConnected() == false)
173         {
174             return false;
175         }
176 
177         return static::$_redis->exists($this->_getCacheId($id, $group));
178     }
179 
180     /**
181      * Get cached data by ID and group
182      *
183      * @param   string   $id         The cache data ID
184      * @param   string   $group      The cache data group
185      * @param   boolean  $checkTime  True to verify cache time expiration threshold
186      *
187      * @return  mixed  Boolean false on failure or a cached data object
188      *
189      * @since   3.4
190      */
191     public function get($id, $group, $checkTime = true)
192     {
193         if (static::isConnected() == false)
194         {
195             return false;
196         }
197 
198         return static::$_redis->get($this->_getCacheId($id, $group));
199     }
200 
201     /**
202      * Get all cached data
203      *
204      * @return  mixed  Boolean false on failure or a cached data object
205      *
206      * @since   3.4
207      */
208     public function getAll()
209     {
210         if (static::isConnected() == false)
211         {
212             return false;
213         }
214 
215         $allKeys = static::$_redis->keys('*');
216         $data    = array();
217         $secret  = $this->_hash;
218 
219         if (!empty($allKeys))
220         {
221             foreach ($allKeys as $key)
222             {
223                 $namearr = explode('-', $key);
224 
225                 if ($namearr !== false && $namearr[0] == $secret && $namearr[1] == 'cache')
226                 {
227                     $group = $namearr[2];
228 
229                     if (!isset($data[$group]))
230                     {
231                         $item = new JCacheStorageHelper($group);
232                     }
233                     else
234                     {
235                         $item = $data[$group];
236                     }
237 
238                     $item->updateSize(strlen($key)*8);
239                     $data[$group] = $item;
240                 }
241             }
242         }
243 
244         return $data;
245     }
246 
247     /**
248      * Store the data to cache by ID and group
249      *
250      * @param   string  $id     The cache data ID
251      * @param   string  $group  The cache data group
252      * @param   string  $data   The data to store in cache
253      *
254      * @return  boolean
255      *
256      * @since   3.4
257      */
258     public function store($id, $group, $data)
259     {
260         if (static::isConnected() == false)
261         {
262             return false;
263         }
264 
265         static::$_redis->setex($this->_getCacheId($id, $group), $this->_lifetime, $data);
266 
267         return true;
268     }
269 
270     /**
271      * Remove a cached data entry by ID and group
272      *
273      * @param   string  $id     The cache data ID
274      * @param   string  $group  The cache data group
275      *
276      * @return  boolean
277      *
278      * @since   3.4
279      */
280     public function remove($id, $group)
281     {
282         if (static::isConnected() == false)
283         {
284             return false;
285         }
286 
287         return (bool) static::$_redis->delete($this->_getCacheId($id, $group));
288     }
289 
290     /**
291      * Clean cache for a group given a mode.
292      *
293      * group mode    : cleans all cache in the group
294      * notgroup mode : cleans all cache not in the group
295      *
296      * @param   string  $group  The cache data group
297      * @param   string  $mode   The mode for cleaning cache [group|notgroup]
298      *
299      * @return  boolean
300      *
301      * @since   3.4
302      */
303     public function clean($group, $mode = null)
304     {
305         if (static::isConnected() == false)
306         {
307             return false;
308         }
309 
310         $allKeys = static::$_redis->keys('*');
311 
312         if ($allKeys === false)
313         {
314             $allKeys = array();
315         }
316 
317         $secret = $this->_hash;
318 
319         foreach ($allKeys as $key)
320         {
321             if (strpos($key, $secret . '-cache-' . $group . '-') === 0 && $mode == 'group')
322             {
323                 static::$_redis->delete($key);
324             }
325 
326             if (strpos($key, $secret . '-cache-' . $group . '-') !== 0 && $mode != 'group')
327             {
328                 static::$_redis->delete($key);
329             }
330         }
331 
332         return true;
333     }
334 
335     /**
336      * Test to see if the storage handler is available.
337      *
338      * @return  boolean
339      *
340      * @since   3.4
341      */
342     public static function isSupported()
343     {
344         return class_exists('Redis');
345     }
346 
347     /**
348      * Test to see if the Redis connection is available.
349      *
350      * @return  boolean
351      *
352      * @since   3.4
353      */
354     public static function isConnected()
355     {
356         return static::$_redis instanceof Redis;
357     }
358 }
359 

Joomla! Framework TM API documentation generated by ApiGen 2.8.0
Joomla!® and Joomla! Framework™ are trademarks of Open Source Matters, Inc. in the United States and other countries.