Support Joomla!

Joomla! 1.5 Documentation

Packages

Package: Joomla-Framework

License

Content on this site is copyright © 2005 - 2008 by the individual contributors and can be used in accordance with the Creative Commons License, Attribution- NonCommercial- ShareAlike 2.5. Some parts of this website may be subject to other licenses.
Source code for file /joomla/cache/storage/file.php

Documentation is available at file.php

  1. <?php
  2. /**
  3.  * @version        $Id: file.php 9764 2007-12-30 07:48:11Z ircmaxell $
  4.  * @package        Joomla.Framework
  5.  * @subpackage    Cache
  6.  * @copyright    Copyright (C) 2005 - 2008 Open Source Matters. All rights reserved.
  7.  * @license        GNU/GPL, see LICENSE.php
  8.  *  Joomla! is free software. This version may have been modified pursuant
  9.  *  to the GNU General Public License, and as distributed it includes or
  10.  *  is derivative of works licensed under the GNU General Public License or
  11.  *  other free or open source software licenses.
  12.  *  See COPYRIGHT.php for copyright notices and details.
  13.  */
  14.  
  15. // Check to ensure this file is within the rest of the framework
  16. defined('JPATH_BASE') or die();
  17.  
  18. /**
  19.  * File cache storage handler
  20.  *
  21.  * @author        Louis Landry <louis.landry@joomla.org>
  22.  * @package        Joomla.Framework
  23.  * @subpackage    Cache
  24.  * @since        1.5
  25.  */
  26. class JCacheStorageFile extends JCacheStorage
  27. {
  28.     /**
  29.     * Constructor
  30.     *
  31.     * @access protected
  32.     * @param array $options optional parameters
  33.     */
  34.     function __construct( $options = array() )
  35.     {
  36.         parent::__construct($options);
  37.  
  38.         $config            =& JFactory::getConfig();
  39.         $this->_root    = $options['cachebase'];
  40.         $this->_hash    = $config->getValue('config.secret');
  41.     }
  42.  
  43.     /**
  44.      * Get cached data from a file by id and group
  45.      *
  46.      * @access    public
  47.      * @param    string    $id            The cache data id
  48.      * @param    string    $group        The cache data group
  49.      * @param    boolean    $checkTime    True to verify cache time expiration threshold
  50.      * @return    mixed    Boolean false on failure or a cached data string
  51.      * @since    1.5
  52.      */
  53.     function get($id, $group, $checkTime)
  54.     {
  55.         $data = false;
  56.  
  57.         $path = $this->_getFilePath($id, $group);
  58.         clearstatcache();
  59.         if (is_file($path)) {
  60.             if ($checkTime) {
  61.                 if (@ filemtime($path) > $this->_threshold) {
  62.                     $data = file_get_contents($path);
  63.                 }
  64.             } else {
  65.                 $data = file_get_contents($path);
  66.             }
  67.         }
  68.         return $data;
  69.     }
  70.  
  71.     /**
  72.      * Store the data to a file by id and group
  73.      *
  74.      * @access    public
  75.      * @param    string    $id        The cache data id
  76.      * @param    string    $group    The cache data group
  77.      * @param    string    $data    The data to store in cache
  78.      * @return    boolean    True on success, false otherwise
  79.      * @since    1.5
  80.      */
  81.     function store($id, $group, $data)
  82.     {
  83.         $written    = false;
  84.         $path        = $this->_getFilePath($id, $group);
  85.  
  86.         $fp = @fopen($path, "wb");
  87.         if ($fp) {
  88.             if ($this->_locking) {
  89.                 @flock($fp, LOCK_EX);
  90.             }
  91.             $len = strlen($data);
  92.             @fwrite($fp, $data, $len);
  93.             if ($this->_locking) {
  94.                 @flock($fp, LOCK_UN);
  95.             }
  96.             @fclose($fp);
  97.             $written = true;
  98.         }
  99.         // Data integrity check
  100.         if ($written && ($data == file_get_contents($path))) {
  101.             return true;
  102.         } else {
  103.             return false;
  104.         }
  105.     }
  106.  
  107.     /**
  108.      * Remove a cached data file by id and group
  109.      *
  110.      * @access    public
  111.      * @param    string    $id        The cache data id
  112.      * @param    string    $group    The cache data group
  113.      * @return    boolean    True on success, false otherwise
  114.      * @since    1.5
  115.      */
  116.     function remove($id, $group)
  117.     {
  118.         $path = $this->_getFilePath($id, $group);
  119.         if (!@unlink($path)) {
  120.             return false;
  121.         }
  122.         return true;
  123.     }
  124.  
  125.     /**
  126.      * Clean cache for a group given a mode.
  127.      *
  128.      * group mode        : cleans all cache in the group
  129.      * notgroup mode    : cleans all cache not in the group
  130.      *
  131.      * @access    public
  132.      * @param    string    $group    The cache data group
  133.      * @param    string    $mode    The mode for cleaning cache [group|notgroup]
  134.      * @return    boolean    True on success, false otherwise
  135.      * @since    1.5
  136.      */
  137.     function clean($group, $mode)
  138.     {
  139.         jimport('joomla.filesystem.folder');
  140.  
  141.         $return = true;
  142.         $folder    = $group;
  143.         switch ($mode)
  144.         {
  145.             case 'notgroup':
  146.                 $folders = JFolder::folders($this->_root);
  147.                 for ($i=0,$n=count($folders);$i<$n;$i++)
  148.                 {
  149.                     if ($folders[$i] != $folder) {
  150.                         $return |= JFolder::delete($this->_root.DS.$folders[$i]);
  151.                     }
  152.                 }
  153.                 break;
  154.             case 'group':
  155.             default:
  156.                 if (is_dir($this->_root.DS.$folder)) {
  157.                     $return = JFolder::delete($this->_root.DS.$folder);
  158.                 }
  159.                 break;
  160.         }
  161.         return $return;
  162.     }
  163.  
  164.     /**
  165.      * Garbage collect expired cache data
  166.      *
  167.      * @access public
  168.      * @return boolean  True on success, false otherwise.
  169.      */
  170.     function gc()
  171.     {
  172.         $result = true;
  173.         // files older than lifeTime get deleted from cache
  174.         if (!is_null($this->_lifeTime)) {
  175.             $files = JFolder::files($this->_root, '.', true, true);
  176.             for ($i=0,$n=count($files);$i<$n;$i++)
  177.             {
  178.                 if (@ filemtime($files[$i]) < $this->_threshold) {
  179.                     $result |= JFile::delete($files[$i]);
  180.                 }
  181.             }
  182.         }
  183.         return $result;
  184.     }
  185.  
  186.     /**
  187.      * Test to see if the cache storage is available.
  188.      *
  189.      * @static
  190.      * @access public
  191.      * @return boolean  True on success, false otherwise.
  192.      */
  193.     function test()
  194.     {
  195.         $config    =& JFactory::getConfig();
  196.         $root    = $config->getValue('config.cache_path', JPATH_ROOT.DS.'cache');
  197.         return is_writable($root);
  198.     }
  199.  
  200.     /**
  201.      * Get a cache file path from an id/group pair
  202.      *
  203.      * @access    private
  204.      * @param    string    $id        The cache data id
  205.      * @param    string    $group    The cache data group
  206.      * @return    string    The cache file path
  207.      * @since    1.5
  208.      */
  209.     function _getFilePath($id, $group)
  210.     {
  211.         $folder    = $group;
  212.         $name    = md5($this->_application.'-'.$id.'-'.$this->_hash.'-'.$this->_language).'.cache';
  213.  
  214.         // If the folder doesn't exist try to create it
  215.         if (!is_dir($this->_root.DS.$folder)) {
  216.             @mkdir($this->_root.DS.$folder);
  217.         }
  218.  
  219.         // Make sure the folder exists
  220.         if (!is_dir($this->_root.DS.$folder)) {
  221.             return false;
  222.         }
  223.         return $this->_root.DS.$folder.DS.$name;
  224.     }
  225. }
Documentation generated on Tue, 29 Jan 2008 18:45:49 +0000 by phpDocumentor 1.3.1