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  * Memcached cache storage handler
 14  *
 15  * @link   https://secure.php.net/manual/en/book.memcached.php
 16  * @since  12.1
 17  */
 18 class JCacheStorageMemcached extends JCacheStorage
 19 {
 20     /**
 21      * Memcached connection object
 22      *
 23      * @var    Memcached
 24      * @since  12.1
 25      */
 26     protected static $_db = null;
 27 
 28     /**
 29      * Payload compression level
 30      *
 31      * @var    integer
 32      * @since  12.1
 33      */
 34     protected $_compress = 0;
 35 
 36     /**
 37      * Constructor
 38      *
 39      * @param   array  $options  Optional parameters.
 40      *
 41      * @since   12.1
 42      */
 43     public function __construct($options = array())
 44     {
 45         parent::__construct($options);
 46 
 47         $this->_compress = JFactory::getConfig()->get('memcached_compress', false) ? Memcached::OPT_COMPRESSION : 0;
 48 
 49         if (static::$_db === null)
 50         {
 51             $this->getConnection();
 52         }
 53     }
 54 
 55     /**
 56      * Create the Memcached connection
 57      *
 58      * @return  void
 59      *
 60      * @since   12.1
 61      * @throws  RuntimeException
 62      */
 63     protected function getConnection()
 64     {
 65         if (!static::isSupported())
 66         {
 67             throw new RuntimeException('Memcached Extension is not available');
 68         }
 69 
 70         $config = JFactory::getConfig();
 71 
 72         $host = $config->get('memcached_server_host', 'localhost');
 73         $port = $config->get('memcached_server_port', 11211);
 74 
 75 
 76         // Create the memcached connection
 77         if ($config->get('memcached_persist', true))
 78         {
 79             static::$_db = new Memcached($this->_hash);
 80             $servers = static::$_db->getServerList();
 81 
 82             if ($servers && ($servers[0]['host'] != $host || $servers[0]['port'] != $port))
 83             {
 84                 static::$_db->resetServerList();
 85                 $servers = array();
 86             }
 87 
 88             if (!$servers)
 89             {
 90                 static::$_db->addServer($host, $port);
 91             }
 92         }
 93         else
 94         {
 95             static::$_db = new Memcached;
 96             static::$_db->addServer($host, $port);
 97         }
 98 
 99         static::$_db->setOption(Memcached::OPT_COMPRESSION, $this->_compress);
100 
101         $stats  = static::$_db->getStats();
102         $result = !empty($stats["$host:$port"]) && $stats["$host:$port"]['pid'] > 0;
103 
104         if (!$result)
105         {
106             // Null out the connection to inform the constructor it will need to attempt to connect if this class is instantiated again
107             static::$_db = null;
108 
109             throw new JCacheExceptionConnecting('Could not connect to memcached server');
110         }
111     }
112 
113     /**
114      * Get a cache_id string from an id/group pair
115      *
116      * @param   string  $id     The cache data id
117      * @param   string  $group  The cache data group
118      *
119      * @return  string   The cache_id string
120      *
121      * @since   11.1
122      */
123     protected function _getCacheId($id, $group)
124     {
125         $prefix   = JCache::getPlatformPrefix();
126         $length   = strlen($prefix);
127         $cache_id = parent::_getCacheId($id, $group);
128 
129         if ($length)
130         {
131             // Memcached use suffix instead of prefix
132             $cache_id = substr($cache_id, $length) . strrev($prefix);
133         }
134 
135         return $cache_id;
136     }
137 
138     /**
139      * Check if the cache contains data stored by ID and group
140      *
141      * @param   string  $id     The cache data ID
142      * @param   string  $group  The cache data group
143      *
144      * @return  boolean
145      *
146      * @since   3.7.0
147      */
148     public function contains($id, $group)
149     {
150         static::$_db->get($this->_getCacheId($id, $group));
151 
152         return static::$_db->getResultCode() !== Memcached::RES_NOTFOUND;
153     }
154 
155     /**
156      * Get cached data by ID and group
157      *
158      * @param   string   $id         The cache data ID
159      * @param   string   $group      The cache data group
160      * @param   boolean  $checkTime  True to verify cache time expiration threshold
161      *
162      * @return  mixed  Boolean false on failure or a cached data object
163      *
164      * @since   12.1
165      */
166     public function get($id, $group, $checkTime = true)
167     {
168         return static::$_db->get($this->_getCacheId($id, $group));
169     }
170 
171     /**
172      * Get all cached data
173      *
174      * @return  mixed  Boolean false on failure or a cached data object
175      *
176      * @since   12.1
177      */
178     public function getAll()
179     {
180         $keys   = static::$_db->get($this->_hash . '-index');
181         $secret = $this->_hash;
182 
183         $data = array();
184 
185         if (is_array($keys))
186         {
187             foreach ($keys as $key)
188             {
189                 if (empty($key))
190                 {
191                     continue;
192                 }
193 
194                 $namearr = explode('-', $key->name);
195 
196                 if ($namearr !== false && $namearr[0] == $secret && $namearr[1] == 'cache')
197                 {
198                     $group = $namearr[2];
199 
200                     if (!isset($data[$group]))
201                     {
202                         $item = new JCacheStorageHelper($group);
203                     }
204                     else
205                     {
206                         $item = $data[$group];
207                     }
208 
209                     $item->updateSize($key->size);
210 
211                     $data[$group] = $item;
212                 }
213             }
214         }
215 
216         return $data;
217     }
218 
219     /**
220      * Store the data to cache by ID and group
221      *
222      * @param   string  $id     The cache data ID
223      * @param   string  $group  The cache data group
224      * @param   string  $data   The data to store in cache
225      *
226      * @return  boolean
227      *
228      * @since   12.1
229      */
230     public function store($id, $group, $data)
231     {
232         $cache_id = $this->_getCacheId($id, $group);
233 
234         if (!$this->lockindex())
235         {
236             return false;
237         }
238 
239         $index = static::$_db->get($this->_hash . '-index');
240 
241         if (!is_array($index))
242         {
243             $index = array();
244         }
245 
246         $tmparr       = new stdClass;
247         $tmparr->name = $cache_id;
248         $tmparr->size = strlen($data);
249 
250         $index[] = $tmparr;
251         static::$_db->set($this->_hash . '-index', $index, 0);
252         $this->unlockindex();
253 
254         static::$_db->set($cache_id, $data, $this->_lifetime);
255 
256         return true;
257     }
258 
259     /**
260      * Remove a cached data entry by ID and group
261      *
262      * @param   string  $id     The cache data ID
263      * @param   string  $group  The cache data group
264      *
265      * @return  boolean
266      *
267      * @since   12.1
268      */
269     public function remove($id, $group)
270     {
271         $cache_id = $this->_getCacheId($id, $group);
272 
273         if (!$this->lockindex())
274         {
275             return false;
276         }
277 
278         $index = static::$_db->get($this->_hash . '-index');
279 
280         if (is_array($index))
281         {
282             foreach ($index as $key => $value)
283             {
284                 if ($value->name == $cache_id)
285                 {
286                     unset($index[$key]);
287                     static::$_db->set($this->_hash . '-index', $index, 0);
288                     break;
289                 }
290             }
291         }
292 
293         $this->unlockindex();
294 
295         return static::$_db->delete($cache_id);
296     }
297 
298     /**
299      * Clean cache for a group given a mode.
300      *
301      * group mode    : cleans all cache in the group
302      * notgroup mode : cleans all cache not in the group
303      *
304      * @param   string  $group  The cache data group
305      * @param   string  $mode   The mode for cleaning cache [group|notgroup]
306      *
307      * @return  boolean
308      *
309      * @since   12.1
310      */
311     public function clean($group, $mode = null)
312     {
313         if (!$this->lockindex())
314         {
315             return false;
316         }
317 
318         $index = static::$_db->get($this->_hash . '-index');
319 
320         if (is_array($index))
321         {
322             $prefix = $this->_hash . '-cache-' . $group . '-';
323 
324             foreach ($index as $key => $value)
325             {
326                 if (strpos($value->name, $prefix) === 0 xor $mode != 'group')
327                 {
328                     static::$_db->delete($value->name);
329                     unset($index[$key]);
330                 }
331             }
332 
333             static::$_db->set($this->_hash . '-index', $index, 0);
334         }
335 
336         $this->unlockindex();
337 
338         return true;
339     }
340 
341     /**
342      * Flush all existing items in storage.
343      *
344      * @return  boolean
345      *
346      * @since   3.6.3
347      */
348     public function flush()
349     {
350         if (!$this->lockindex())
351         {
352             return false;
353         }
354 
355         return static::$_db->flush();
356     }
357 
358     /**
359      * Test to see if the storage handler is available.
360      *
361      * @return  boolean
362      *
363      * @since   12.1
364      */
365     public static function isSupported()
366     {
367         /*
368          * GAE and HHVM have both had instances where Memcached the class was defined but no extension was loaded.
369          * If the class is there, we can assume support.
370          */
371         return class_exists('Memcached');
372     }
373 
374     /**
375      * Lock cached item
376      *
377      * @param   string   $id        The cache data ID
378      * @param   string   $group     The cache data group
379      * @param   integer  $locktime  Cached item max lock time
380      *
381      * @return  mixed  Boolean false if locking failed or an object containing properties lock and locklooped
382      *
383      * @since   12.1
384      */
385     public function lock($id, $group, $locktime)
386     {
387         $returning = new stdClass;
388         $returning->locklooped = false;
389 
390         $looptime = $locktime * 10;
391 
392         $cache_id = $this->_getCacheId($id, $group);
393 
394         $data_lock = static::$_db->add($cache_id . '_lock', 1, $locktime);
395 
396         if ($data_lock === false)
397         {
398             $lock_counter = 0;
399 
400             // Loop until you find that the lock has been released.
401             // That implies that data get from other thread has finished.
402             while ($data_lock === false)
403             {
404                 if ($lock_counter > $looptime)
405                 {
406                     break;
407                 }
408 
409                 usleep(100);
410                 $data_lock = static::$_db->add($cache_id . '_lock', 1, $locktime);
411                 $lock_counter++;
412             }
413 
414             $returning->locklooped = true;
415         }
416 
417         $returning->locked = $data_lock;
418 
419         return $returning;
420     }
421 
422     /**
423      * Unlock cached item
424      *
425      * @param   string  $id     The cache data ID
426      * @param   string  $group  The cache data group
427      *
428      * @return  boolean
429      *
430      * @since   12.1
431      */
432     public function unlock($id, $group = null)
433     {
434         $cache_id = $this->_getCacheId($id, $group) . '_lock';
435         return static::$_db->delete($cache_id);
436     }
437 
438     /**
439      * Lock cache index
440      *
441      * @return  boolean
442      *
443      * @since   12.1
444      */
445     protected function lockindex()
446     {
447         $looptime  = 300;
448         $data_lock = static::$_db->add($this->_hash . '-index_lock', 1, 30);
449 
450         if ($data_lock === false)
451         {
452             $lock_counter = 0;
453 
454             // Loop until you find that the lock has been released.  that implies that data get from other thread has finished
455             while ($data_lock === false)
456             {
457                 if ($lock_counter > $looptime)
458                 {
459                     return false;
460                 }
461 
462                 usleep(100);
463                 $data_lock = static::$_db->add($this->_hash . '-index_lock', 1, 30);
464                 $lock_counter++;
465             }
466         }
467 
468         return true;
469     }
470 
471     /**
472      * Unlock cache index
473      *
474      * @return  boolean
475      *
476      * @since   12.1
477      */
478     protected function unlockindex()
479     {
480         return static::$_db->delete($this->_hash . '-index_lock');
481     }
482 }
483 

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.