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 use Joomla\String\StringHelper;
 13 
 14 /**
 15  * Joomla! Cache base object
 16  *
 17  * @since  11.1
 18  */
 19 class JCache
 20 {
 21     /**
 22      * Storage handler
 23      *
 24      * @var    JCacheStorage[]
 25      * @since  11.1
 26      */
 27     public static $_handler = array();
 28 
 29     /**
 30      * Cache options
 31      *
 32      * @var    array
 33      * @since  11.1
 34      */
 35     public $_options;
 36 
 37     /**
 38      * Constructor
 39      *
 40      * @param   array  $options  Cache options
 41      *
 42      * @since   11.1
 43      */
 44     public function __construct($options)
 45     {
 46         $conf = JFactory::getConfig();
 47 
 48         $this->_options = array(
 49             'cachebase'    => $conf->get('cache_path', JPATH_CACHE),
 50             'lifetime'     => (int) $conf->get('cachetime'),
 51             'language'     => $conf->get('language', 'en-GB'),
 52             'storage'      => $conf->get('cache_handler', ''),
 53             'defaultgroup' => 'default',
 54             'locking'      => true,
 55             'locktime'     => 15,
 56             'checkTime'    => true,
 57             'caching'      => ($conf->get('caching') >= 1) ? true : false,
 58         );
 59 
 60         // Overwrite default options with given options
 61         foreach ($options as $option => $value)
 62         {
 63             if (isset($options[$option]) && $options[$option] !== '')
 64             {
 65                 $this->_options[$option] = $options[$option];
 66             }
 67         }
 68 
 69         if (empty($this->_options['storage']))
 70         {
 71             $this->setCaching(false);
 72         }
 73     }
 74 
 75     /**
 76      * Returns a reference to a cache adapter object, always creating it
 77      *
 78      * @param   string  $type     The cache object type to instantiate
 79      * @param   array   $options  The array of options
 80      *
 81      * @return  JCacheController
 82      *
 83      * @since   11.1
 84      */
 85     public static function getInstance($type = 'output', $options = array())
 86     {
 87         return JCacheController::getInstance($type, $options);
 88     }
 89 
 90     /**
 91      * Get the storage handlers
 92      *
 93      * @return  array
 94      *
 95      * @since   11.1
 96      */
 97     public static function getStores()
 98     {
 99         $handlers = array();
100 
101         // Get an iterator and loop trough the driver classes.
102         $iterator = new DirectoryIterator(__DIR__ . '/storage');
103 
104         /** @type  $file  DirectoryIterator */
105         foreach ($iterator as $file)
106         {
107             $fileName = $file->getFilename();
108 
109             // Only load for php files.
110             if (!$file->isFile() || $file->getExtension() != 'php' || $fileName == 'helper.php')
111             {
112                 continue;
113             }
114 
115             // Derive the class name from the type.
116             $class = str_ireplace('.php', '', 'JCacheStorage' . ucfirst(trim($fileName)));
117 
118             // If the class doesn't exist we have nothing left to do but look at the next type. We did our best.
119             if (!class_exists($class))
120             {
121                 continue;
122             }
123 
124             // Sweet!  Our class exists, so now we just need to know if it passes its test method.
125             if ($class::isSupported())
126             {
127                 // Connector names should not have file extensions.
128                 $handlers[] = str_ireplace('.php', '', $fileName);
129             }
130         }
131 
132         return $handlers;
133     }
134 
135     /**
136      * Set caching enabled state
137      *
138      * @param   boolean  $enabled  True to enable caching
139      *
140      * @return  void
141      *
142      * @since   11.1
143      */
144     public function setCaching($enabled)
145     {
146         $this->_options['caching'] = $enabled;
147     }
148 
149     /**
150      * Get caching state
151      *
152      * @return  boolean
153      *
154      * @since   11.1
155      */
156     public function getCaching()
157     {
158         return $this->_options['caching'];
159     }
160 
161     /**
162      * Set cache lifetime
163      *
164      * @param   integer  $lt  Cache lifetime
165      *
166      * @return  void
167      *
168      * @since   11.1
169      */
170     public function setLifeTime($lt)
171     {
172         $this->_options['lifetime'] = $lt;
173     }
174 
175     /**
176      * Check if the cache contains data stored by ID and group
177      *
178      * @param   string  $id     The cache data ID
179      * @param   string  $group  The cache data group
180      *
181      * @return  boolean
182      *
183      * @since   3.7.0
184      */
185     public function contains($id, $group = null)
186     {
187         if (!$this->getCaching())
188         {
189             return false;
190         }
191 
192         // Get the default group
193         $group = $group ?: $this->_options['defaultgroup'];
194 
195         return $this->_getStorage()->contains($id, $group);
196     }
197 
198     /**
199      * Get cached data by ID and group
200      *
201      * @param   string  $id     The cache data ID
202      * @param   string  $group  The cache data group
203      *
204      * @return  mixed  Boolean false on failure or a cached data object
205      *
206      * @since   11.1
207      */
208     public function get($id, $group = null)
209     {
210         if (!$this->getCaching())
211         {
212             return false;
213         }
214 
215         // Get the default group
216         $group = $group ?: $this->_options['defaultgroup'];
217 
218         return $this->_getStorage()->get($id, $group, $this->_options['checkTime']);
219     }
220 
221     /**
222      * Get a list of all cached data
223      *
224      * @return  mixed  Boolean false on failure or an object with a list of cache groups and data
225      *
226      * @since   11.1
227      */
228     public function getAll()
229     {
230         if (!$this->getCaching())
231         {
232             return false;
233         }
234 
235         return $this->_getStorage()->getAll();
236     }
237 
238     /**
239      * Store the cached data by ID and group
240      *
241      * @param   mixed   $data   The data to store
242      * @param   string  $id     The cache data ID
243      * @param   string  $group  The cache data group
244      *
245      * @return  boolean
246      *
247      * @since   11.1
248      */
249     public function store($data, $id, $group = null)
250     {
251         if (!$this->getCaching())
252         {
253             return false;
254         }
255 
256         // Get the default group
257         $group = $group ?: $this->_options['defaultgroup'];
258 
259         // Get the storage and store the cached data
260         return $this->_getStorage()->store($id, $group, $data);
261     }
262 
263     /**
264      * Remove a cached data entry by ID and group
265      *
266      * @param   string  $id     The cache data ID
267      * @param   string  $group  The cache data group
268      *
269      * @return  boolean
270      *
271      * @since   11.1
272      */
273     public function remove($id, $group = null)
274     {
275         // Get the default group
276         $group = $group ?: $this->_options['defaultgroup'];
277 
278         return $this->_getStorage()->remove($id, $group);
279     }
280 
281     /**
282      * Clean cache for a group given a mode.
283      *
284      * group mode    : cleans all cache in the group
285      * notgroup mode : cleans all cache not in the group
286      *
287      * @param   string  $group  The cache data group
288      * @param   string  $mode   The mode for cleaning cache [group|notgroup]
289      *
290      * @return  boolean  True on success, false otherwise
291      *
292      * @since   11.1
293      */
294     public function clean($group = null, $mode = 'group')
295     {
296         // Get the default group
297         $group = $group ?: $this->_options['defaultgroup'];
298 
299         return $this->_getStorage()->clean($group, $mode);
300     }
301 
302     /**
303      * Garbage collect expired cache data
304      *
305      * @return  boolean
306      *
307      * @since   11.1
308      */
309     public function gc()
310     {
311         return $this->_getStorage()->gc();
312     }
313 
314     /**
315      * Set lock flag on cached item
316      *
317      * @param   string  $id        The cache data ID
318      * @param   string  $group     The cache data group
319      * @param   string  $locktime  The default locktime for locking the cache.
320      *
321      * @return  stdClass  Object with properties of lock and locklooped
322      *
323      * @since   11.1
324      */
325     public function lock($id, $group = null, $locktime = null)
326     {
327         $returning = new stdClass;
328         $returning->locklooped = false;
329 
330         if (!$this->getCaching())
331         {
332             $returning->locked = false;
333 
334             return $returning;
335         }
336 
337         // Get the default group
338         $group = $group ?: $this->_options['defaultgroup'];
339 
340         // Get the default locktime
341         $locktime = $locktime ?: $this->_options['locktime'];
342 
343         /*
344          * Allow storage handlers to perform locking on their own
345          * NOTE drivers with lock need also unlock or unlocking will fail because of false $id
346          */
347         $handler = $this->_getStorage();
348 
349         if ($this->_options['locking'] == true)
350         {
351             $locked = $handler->lock($id, $group, $locktime);
352 
353             if ($locked !== false)
354             {
355                 return $locked;
356             }
357         }
358 
359         // Fallback
360         $curentlifetime = $this->_options['lifetime'];
361 
362         // Set lifetime to locktime for storing in children
363         $this->_options['lifetime'] = $locktime;
364 
365         $looptime = $locktime * 10;
366         $id2      = $id . '_lock';
367 
368         if ($this->_options['locking'] == true)
369         {
370             $data_lock = $handler->get($id2, $group, $this->_options['checkTime']);
371         }
372         else
373         {
374             $data_lock         = false;
375             $returning->locked = false;
376         }
377 
378         if ($data_lock !== false)
379         {
380             $lock_counter = 0;
381 
382             // Loop until you find that the lock has been released. That implies that data get from other thread has finished
383             while ($data_lock !== false)
384             {
385                 if ($lock_counter > $looptime)
386                 {
387                     $returning->locked = false;
388                     $returning->locklooped = true;
389                     break;
390                 }
391 
392                 usleep(100);
393                 $data_lock = $handler->get($id2, $group, $this->_options['checkTime']);
394                 $lock_counter++;
395             }
396         }
397 
398         if ($this->_options['locking'] == true)
399         {
400             $returning->locked = $handler->store(1, $id2, $group);
401         }
402 
403         // Revert lifetime to previous one
404         $this->_options['lifetime'] = $curentlifetime;
405 
406         return $returning;
407     }
408 
409     /**
410      * Unset lock flag on cached item
411      *
412      * @param   string  $id     The cache data ID
413      * @param   string  $group  The cache data group
414      *
415      * @return  boolean
416      *
417      * @since   11.1
418      */
419     public function unlock($id, $group = null)
420     {
421         if (!$this->getCaching())
422         {
423             return false;
424         }
425 
426         // Get the default group
427         $group = $group ?: $this->_options['defaultgroup'];
428 
429         // Allow handlers to perform unlocking on their own
430         $handler = $this->_getStorage();
431 
432         $unlocked = $handler->unlock($id, $group);
433 
434         if ($unlocked !== false)
435         {
436             return $unlocked;
437         }
438 
439         // Fallback
440         return $handler->remove($id . '_lock', $group);
441     }
442 
443     /**
444      * Get the cache storage handler
445      *
446      * @return  JCacheStorage
447      *
448      * @since   11.1
449      */
450     public function &_getStorage()
451     {
452         $hash = md5(serialize($this->_options));
453 
454         if (isset(self::$_handler[$hash]))
455         {
456             return self::$_handler[$hash];
457         }
458 
459         self::$_handler[$hash] = JCacheStorage::getInstance($this->_options['storage'], $this->_options);
460 
461         return self::$_handler[$hash];
462     }
463 
464     /**
465      * Perform workarounds on retrieved cached data
466      *
467      * @param   string  $data     Cached data
468      * @param   array   $options  Array of options
469      *
470      * @return  string  Body of cached data
471      *
472      * @since   11.1
473      */
474     public static function getWorkarounds($data, $options = array())
475     {
476         $app      = JFactory::getApplication();
477         $document = JFactory::getDocument();
478         $body     = null;
479 
480         // Get the document head out of the cache.
481         if (isset($options['mergehead']) && $options['mergehead'] == 1 && isset($data['head']) && !empty($data['head'])
482             && method_exists($document, 'mergeHeadData'))
483         {
484             $document->mergeHeadData($data['head']);
485         }
486         elseif (isset($data['head']) && method_exists($document, 'setHeadData'))
487         {
488             $document->setHeadData($data['head']);
489         }
490 
491         // Get the document MIME encoding out of the cache
492         if (isset($data['mime_encoding']))
493         {
494             $document->setMimeEncoding($data['mime_encoding'], true);
495         }
496 
497         // If the pathway buffer is set in the cache data, get it.
498         if (isset($data['pathway']) && is_array($data['pathway']))
499         {
500             // Push the pathway data into the pathway object.
501             $app->getPathway()->setPathway($data['pathway']);
502         }
503 
504         // @todo check if the following is needed, seems like it should be in page cache
505         // If a module buffer is set in the cache data, get it.
506         if (isset($data['module']) && is_array($data['module']))
507         {
508             // Iterate through the module positions and push them into the document buffer.
509             foreach ($data['module'] as $name => $contents)
510             {
511                 $document->setBuffer($contents, 'module', $name);
512             }
513         }
514 
515         // Set cached headers.
516         if (isset($data['headers']) && $data['headers'])
517         {
518             foreach ($data['headers'] as $header)
519             {
520                 $app->setHeader($header['name'], $header['value']);
521             }
522         }
523 
524         // The following code searches for a token in the cached page and replaces it with the proper token.
525         if (isset($data['body']))
526         {
527             $token       = JSession::getFormToken();
528             $search      = '#<input type="hidden" name="[0-9a-f]{32}" value="1" />#';
529             $replacement = '<input type="hidden" name="' . $token . '" value="1" />';
530 
531             $data['body'] = preg_replace($search, $replacement, $data['body']);
532             $body         = $data['body'];
533         }
534 
535         // Get the document body out of the cache.
536         return $body;
537     }
538 
539     /**
540      * Create workarounds for data to be cached
541      *
542      * @param   string  $data     Cached data
543      * @param   array   $options  Array of options
544      *
545      * @return  string  Data to be cached
546      *
547      * @since   11.1
548      */
549     public static function setWorkarounds($data, $options = array())
550     {
551         $loptions = array(
552             'nopathway'  => 0,
553             'nohead'     => 0,
554             'nomodules'  => 0,
555             'modulemode' => 0,
556         );
557 
558         if (isset($options['nopathway']))
559         {
560             $loptions['nopathway'] = $options['nopathway'];
561         }
562 
563         if (isset($options['nohead']))
564         {
565             $loptions['nohead'] = $options['nohead'];
566         }
567 
568         if (isset($options['nomodules']))
569         {
570             $loptions['nomodules'] = $options['nomodules'];
571         }
572 
573         if (isset($options['modulemode']))
574         {
575             $loptions['modulemode'] = $options['modulemode'];
576         }
577 
578         $app      = JFactory::getApplication();
579         $document = JFactory::getDocument();
580 
581         if ($loptions['nomodules'] != 1)
582         {
583             // Get the modules buffer before component execution.
584             $buffer1 = $document->getBuffer();
585 
586             if (!is_array($buffer1))
587             {
588                 $buffer1 = array();
589             }
590 
591             // Make sure the module buffer is an array.
592             if (!isset($buffer1['module']) || !is_array($buffer1['module']))
593             {
594                 $buffer1['module'] = array();
595             }
596         }
597 
598         // View body data
599         $cached['body'] = $data;
600 
601         // Document head data
602         if ($loptions['nohead'] != 1 && method_exists($document, 'getHeadData'))
603         {
604             if ($loptions['modulemode'] == 1)
605             {
606                 $headnow = $document->getHeadData();
607                 $unset   = array('title', 'description', 'link', 'links', 'metaTags');
608 
609                 foreach ($unset as $un)
610                 {
611                     unset($headnow[$un]);
612                     unset($options['headerbefore'][$un]);
613                 }
614 
615                 $cached['head'] = array();
616 
617                 // Only store what this module has added
618                 foreach ($headnow as $now => $value)
619                 {
620                     if (isset($options['headerbefore'][$now]))
621                     {
622                         // We have to serialize the content of the arrays because the may contain other arrays which is a notice in PHP 5.4 and newer
623                         $nowvalue    = array_map('serialize', $headnow[$now]);
624                         $beforevalue = array_map('serialize', $options['headerbefore'][$now]);
625 
626                         $newvalue = array_diff_assoc($nowvalue, $beforevalue);
627                         $newvalue = array_map('unserialize', $newvalue);
628 
629                         // Special treatment for script and style declarations.
630                         if (($now == 'script' || $now == 'style') && is_array($newvalue) && is_array($options['headerbefore'][$now]))
631                         {
632                             foreach ($newvalue as $type => $currentScriptStr)
633                             {
634                                 if (isset($options['headerbefore'][$now][strtolower($type)]))
635                                 {
636                                     $oldScriptStr = $options['headerbefore'][$now][strtolower($type)];
637 
638                                     if ($oldScriptStr != $currentScriptStr)
639                                     {
640                                         // Save only the appended declaration.
641                                         $newvalue[strtolower($type)] = StringHelper::substr($currentScriptStr, StringHelper::strlen($oldScriptStr));
642                                     }
643                                 }
644                             }
645                         }
646                     }
647                     else
648                     {
649                         $newvalue = $headnow[$now];
650                     }
651 
652                     if (!empty($newvalue))
653                     {
654                         $cached['head'][$now] = $newvalue;
655                     }
656                 }
657             }
658             else
659             {
660                 $cached['head'] = $document->getHeadData();
661             }
662         }
663 
664         // Document MIME encoding
665         $cached['mime_encoding'] = $document->getMimeEncoding();
666 
667         // Pathway data
668         if ($app->isClient('site') && $loptions['nopathway'] != 1)
669         {
670             $cached['pathway'] = is_array($data) && isset($data['pathway']) ? $data['pathway'] : $app->getPathway()->getPathway();
671         }
672 
673         if ($loptions['nomodules'] != 1)
674         {
675             // @todo Check if the following is needed, seems like it should be in page cache
676             // Get the module buffer after component execution.
677             $buffer2 = $document->getBuffer();
678 
679             if (!is_array($buffer2))
680             {
681                 $buffer2 = array();
682             }
683 
684             // Make sure the module buffer is an array.
685             if (!isset($buffer2['module']) || !is_array($buffer2['module']))
686             {
687                 $buffer2['module'] = array();
688             }
689 
690             // Compare the second module buffer against the first buffer.
691             $cached['module'] = array_diff_assoc($buffer2['module'], $buffer1['module']);
692         }
693 
694         // Headers data
695         if (isset($options['headers']) && $options['headers'])
696         {
697             $cached['headers'] = $app->getHeaders();
698         }
699 
700         return $cached;
701     }
702 
703     /**
704      * Create a safe ID for cached data from URL parameters
705      *
706      * @return  string  MD5 encoded cache ID
707      *
708      * @since   11.1
709      */
710     public static function makeId()
711     {
712         $app = JFactory::getApplication();
713 
714         $registeredurlparams = new stdClass;
715 
716         // Get url parameters set by plugins
717         if (!empty($app->registeredurlparams))
718         {
719             $registeredurlparams = $app->registeredurlparams;
720         }
721 
722         // Platform defaults
723         $defaulturlparams = array(
724             'format' => 'WORD',
725             'option' => 'WORD',
726             'view'   => 'WORD',
727             'layout' => 'WORD',
728             'tpl'    => 'CMD',
729             'id'     => 'INT',
730         );
731 
732         // Use platform defaults if parameter doesn't already exist.
733         foreach ($defaulturlparams as $param => $type)
734         {
735             if (!property_exists($registeredurlparams, $param))
736             {
737                 $registeredurlparams->$param = $type;
738             }
739         }
740 
741         $safeuriaddon = new stdClass;
742 
743         foreach ($registeredurlparams as $key => $value)
744         {
745             $safeuriaddon->$key = $app->input->get($key, null, $value);
746         }
747 
748         return md5(serialize($safeuriaddon));
749     }
750 
751     /**
752      * Set a prefix cache key if device calls for separate caching
753      *
754      * @return  string
755      *
756      * @since   3.5
757      */
758     public static function getPlatformPrefix()
759     {
760         // No prefix when Global Config is set to no platfom specific prefix
761         if (!JFactory::getConfig()->get('cache_platformprefix', '0'))
762         {
763             return '';
764         }
765 
766         $webclient = new JApplicationWebClient;
767 
768         if ($webclient->mobile)
769         {
770             return 'M-';
771         }
772 
773         return '';
774     }
775 
776     /**
777      * Add a directory where JCache should search for handlers. You may either pass a string or an array of directories.
778      *
779      * @param   array|string  $path  A path to search.
780      *
781      * @return  array   An array with directory elements
782      *
783      * @since   11.1
784      */
785     public static function addIncludePath($path = '')
786     {
787         static $paths;
788 
789         if (!isset($paths))
790         {
791             $paths = array();
792         }
793 
794         if (!empty($path) && !in_array($path, $paths))
795         {
796             jimport('joomla.filesystem.path');
797             array_unshift($paths, JPath::clean($path));
798         }
799 
800         return $paths;
801     }
802 }
803 

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.