Support Joomla!

Joomla! 1.5 Documentation

Packages

Package: Joomla-Framework

Developer Network License

The Joomla! Developer Network content is © copyright 2006 by the individual contributors and can be used in accordance with the Creative Commons License, Attribution- NonCommercial- ShareAlike 2.5
Source code for file /joomla/cache/storage/file.php

Documentation is available at file.php

  1. <?php
  2. /**
  3.  * @version        $Id: file.php 6719 2007-02-25 00:31:45Z Jinx $
  4.  * @package        Joomla.Framework
  5.  * @subpackage    Cache
  6.  * @copyright    Copyright (C) 2005 - 2007 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 <[email protected]>
  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.         if ($this->_application) {
  41.             $this->_root = $this->_root.DS.$this->_application;
  42.         }
  43.         $this->_hash    = $config->getValue('config.secret');
  44.     }
  45.  
  46.     /**
  47.      * Get cached data from a file by id and group
  48.      *
  49.      * @access    public
  50.      * @param    string    $id            The cache data id
  51.      * @param    string    $group        The cache data group
  52.      * @param    boolean    $checkTime    True to verify cache time expiration threshold
  53.      * @return    mixed    Boolean false on failure or a cached data string
  54.      * @since    1.5
  55.      */
  56.     function get($id, $group, $checkTime)
  57.     {
  58.         $data = false;
  59.  
  60.         $path = $this->_getFilePath($id, $group);
  61.         clearstatcache();
  62.         if (is_file($path)) {
  63.             if ($checkTime) {
  64.                 if (@ filemtime($path) > $this->_threshold) {
  65.                     $data = file_get_contents($path);
  66.                 }
  67.             } else {
  68.                 $data = file_get_contents($path);
  69.             }
  70.         }
  71.         return $data;
  72.     }
  73.  
  74.     /**
  75.      * Store the data to a file by id and group
  76.      *
  77.      * @access    public
  78.      * @param    string    $id        The cache data id
  79.      * @param    string    $group    The cache data group
  80.      * @param    string    $data    The data to store in cache
  81.      * @return    boolean    True on success, false otherwise
  82.      * @since    1.5
  83.      */
  84.     function store($id, $group, $data)
  85.     {
  86.         $written    = false;
  87.         $path        = $this->_getFilePath($id, $group);
  88.  
  89.         $fp = @fopen($path, "wb");
  90.         if ($fp) {
  91.             if ($this->_locking) {
  92.                 @flock($fp, LOCK_EX);
  93.             }
  94.             $len = strlen($data);
  95.             @fwrite($fp, $data, $len);
  96.             if ($this->_locking) {
  97.                 @flock($fp, LOCK_UN);
  98.             }
  99.             @fclose($fp);
  100.             $written = true;
  101.         }
  102.         // Data integrity check
  103.         if ($written && ($data == file_get_contents($path))) {
  104.             return true;
  105.         } else {
  106.             return false;
  107.         }
  108.     }
  109.  
  110.     /**
  111.      * Remove a cached data file by id and group
  112.      *
  113.      * @access    public
  114.      * @param    string    $id        The cache data id
  115.      * @param    string    $group    The cache data group
  116.      * @return    boolean    True on success, false otherwise
  117.      * @since    1.5
  118.      */
  119.     function remove($id, $group)
  120.     {
  121.         $path = $this->_getFilePath($id, $group);
  122.         if (!@unlink($path)) {
  123.             return false;
  124.         }
  125.         return true;
  126.     }
  127.  
  128.     /**
  129.      * Clean cache for a group given a mode.
  130.      *
  131.      * group mode        : cleans all cache in the group
  132.      * notgroup mode    : cleans all cache not in the group
  133.      *
  134.      * @access    public
  135.      * @param    string    $group    The cache data group
  136.      * @param    string    $mode    The mode for cleaning cache [group|notgroup]
  137.      * @return    boolean    True on success, false otherwise
  138.      * @since    1.5
  139.      */
  140.     function clean($group, $mode)
  141.     {
  142.         jimport('joomla.filesystem.folder');
  143.  
  144.         $return = true;
  145.         $folder    = md5($group.'-'.$this->_hash);
  146.         switch ($mode)
  147.         {
  148.             case 'notgroup':
  149.                 $folders = JFolder::folders($this->_root);
  150.                 for ($i=0,$n=count($folders);$i<$n;$i++)
  151.                 {
  152.                     if ($folders[$i] != $folder) {
  153.                         $return |= JFolder::delete($this->_root.DS.$folders[$i]);
  154.                     }
  155.                 }
  156.                 break;
  157.             case 'group':
  158.             default:
  159.                 if (is_dir($this->_root.DS.$folder)) {
  160.                     $return = JFolder::delete($this->_root.DS.$folder);
  161.                 }
  162.                 break;
  163.         }
  164.         return $return;
  165.     }
  166.  
  167.     /**
  168.      * Garbage collect expired cache data
  169.      *
  170.      * @access public
  171.      * @return boolean  True on success, false otherwise.
  172.      */
  173.     function gc()
  174.     {
  175.         $result = true;
  176.         // files older than lifeTime get deleted from cache
  177.         if (!is_null($this->_lifeTime)) {
  178.             $files = JFolder::files($this->_root, '.', true, true);
  179.             for ($i=0,$n=count($files);$i<$n;$i++)
  180.             {
  181.                 if (@ filemtime($files[$i]) < $this->_threshold) {
  182.                     $result |= JFile::delete($files[$i]);
  183.                 }
  184.             }
  185.         }
  186.         return $result;
  187.     }
  188.  
  189.     /**
  190.      * Test to see if the cache storage is available.
  191.      *
  192.      * @static
  193.      * @access public
  194.      * @return boolean  True on success, false otherwise.
  195.      */
  196.     function test()
  197.     {
  198.         $config    =& JFactory::getConfig();
  199.         $root    = $config->getValue('config.cache_path', JPATH_ROOT.DS.'cache');
  200.         return is_writable($root);
  201.     }
  202.  
  203.     /**
  204.      * Get a cache file path from an id/group pair
  205.      *
  206.      * @access    private
  207.      * @param    string    $id        The cache data id
  208.      * @param    string    $group    The cache data group
  209.      * @return    string    The cache file path
  210.      * @since    1.5
  211.      */
  212.     function _getFilePath($id, $group)
  213.     {
  214.         $folder    = md5($group.'-'.$this->_hash);
  215.         $name    = md5($id.'-'.$this->_hash).'.cache';
  216.  
  217.         // If the folder doesn't exist try to create it
  218.         if (!is_dir($this->_root.DS.$folder)) {
  219.             @mkdir($this->_root.DS.$folder);
  220.         }
  221.  
  222.         // Make sure the folder exists
  223.         if (!is_dir($this->_root.DS.$folder)) {
  224.             return false;
  225.         }
  226.         return $this->_root.DS.$folder.DS.$name;
  227.     }
  228. }
  229. ?>
Documentation generated on Mon, 05 Mar 2007 20:58:51 +0000 by phpDocumentor 1.3.1