1. sfFileCache.class.php
  2. /**
 * Cache class that stores content in files.
 *
 * @package    symfony
 * @subpackage cache
 * @author     Fabien Potencier 
 * @version    SVN: $Id: sfFileCache.class.php 23810 2009-11-12 11:07:44Z Kris.Wallsmith $
 */
  3. class sfFileCache extends sfCache
  4. {
  5.   const READ_DATA = 1;
  6.   const READ_TIMEOUT = 2;
  7.   const READ_LAST_MODIFIED = 4;
  9.   const EXTENSION = '.cache';
  11.  /**
  12.   * Initializes this sfCache instance.
  13.   *
  14.   * Available options:
  15.   *
  16.   * * cache_dir: The directory where to put cache files
  17.   *
  18.   * * see sfCache for options available for all drivers
  19.   *
  20.   * @see sfCache
  21.   */
  22.   public function initialize($options = array())
  23.   {
  24.     parent::initialize($options);
  26.     if (!$this->getOption('cache_dir'))
  27.     {
  28.       throw new sfInitializationException('You must pass a "cache_dir" option to initialize a sfFileCache object.');
  29.     }
  31.     $this->setcache_dir($this->getOption('cache_dir'));
  32.   }
  34.   /**
  35.    * @see sfCache
  36.    */
  37.   public function get($key, $default = null)
  38.   {
  39.     $file_path = $this->getFilePath($key);
  40.     if (!file_exists($file_path))
  41.     {
  42.       return $default;
  43.     }
  45.     $data = $this->read($file_path, self::READ_DATA);
  47.     if ($data[self::READ_DATA] === null)
  48.     {
  49.       return $default;
  50.     }
  52.     return $data[self::READ_DATA];
  53.   }
  55.   /**
  56.    * @see sfCache
  57.    */
  58.   public function has($key)
  59.   {
  60.     $path = $this->getFilePath($key);
  61.     return file_exists($path) && $this->isValid($path);
  62.   }
  64.   /**
  65.    * @see sfCache
  66.    */
  67.   public function set($key, $data, $lifetime = null)
  68.   {
  69.     if ($this->getOption('automatic_cleaning_factor') > 0 && rand(1, $this->getOption('automatic_cleaning_factor')) == 1)
  70.     {
  71.       $this->clean(sfCache::OLD);
  72.     }
  74.     return $this->write($this->getFilePath($key), $data, time() + $this->getLifetime($lifetime));
  75.   }
  77.   /**
  78.    * @see sfCache
  79.    */
  80.   public function remove($key)
  81.   {
  82.     return @unlink($this->getFilePath($key));
  83.   }
  85.   /**
  86.    * @see sfCache
  87.    */
  88.   public function removePattern($pattern)
  89.   {
  90.     if (false !== strpos($pattern, '**'))
  91.     {
  92.       $pattern = str_replace(sfCache::SEPARATOR, DIRECTORY_SEPARATOR, $pattern).self::EXTENSION;
  94.       $regexp = self::patternToRegexp($pattern);
  95.       $paths = array();
  96.       foreach (new RecursiveIteratorIterator(new RecursiveDirectoryIterator($this->getOption('cache_dir'))) as $path)
  97.       {
  98.         if (preg_match($regexp, str_replace($this->getOption('cache_dir').DIRECTORY_SEPARATOR, '', $path)))
  99.         {
  100.           $paths[] = $path;
  101.         }
  102.       }
  103.     }
  104.     else
  105.     {
  106.       $paths = glob($this->getOption('cache_dir').DIRECTORY_SEPARATOR.str_replace(sfCache::SEPARATOR, DIRECTORY_SEPARATOR, $pattern).self::EXTENSION);
  107.     }
  109.     foreach ($paths as $path)
  110.     {
  111.       if (is_dir($path))
  112.       {
  113.         sfToolkit::clearDirectory($path);
  114.       }
  115.       else
  116.       {
  117.         @unlink($path);
  118.       }
  119.     }
  120.   }
  122.   /**
  123.    * @see sfCache
  124.    */
  125.   public function clean($mode = sfCache::ALL)
  126.   {
  127.     if (!is_dir($this->getOption('cache_dir')))
  128.     {
  129.       return true;
  130.     }
  132.     $result = true;
  133.     foreach (new RecursiveIteratorIterator(new RecursiveDirectoryIterator($this->getOption('cache_dir'))) as $file)
  134.     {
  135.       if (sfCache::ALL == $mode || !$this->isValid($file))
  136.       {
  137.         $result = @unlink($file) && $result;
  138.       }
  139.     }
  141.     return $result;
  142.   }
  144.   /**
  145.    * @see sfCache
  146.    */
  147.   public function getTimeout($key)
  148.   {
  149.     $path = $this->getFilePath($key);
  151.     if (!file_exists($path))
  152.     {
  153.       return 0;
  154.     }
  156.     $data = $this->read($path, self::READ_TIMEOUT);
  158.     return $data[self::READ_TIMEOUT] < time() ? 0 : $data[self::READ_TIMEOUT];
  159.   }
  161.   /**
  162.    * @see sfCache
  163.    */
  164.   public function getLastModified($key)
  165.   {
  166.     $path = $this->getFilePath($key);
  168.     if (!file_exists($path))
  169.     {
  170.       return 0;
  171.     }
  172.     
  173.     $data = $this->read($path, self::READ_TIMEOUT | self::READ_LAST_MODIFIED);
  175.     if ($data[self::READ_TIMEOUT] < time())
  176.     {
  177.       return 0;
  178.     }
  179.     return $data[self::READ_LAST_MODIFIED];
  180.   }
  182.   protected function isValid($path)
  183.   {
  184.     $data = $this->read($path, self::READ_TIMEOUT);
  185.     return time() < $data[self::READ_TIMEOUT];
  186.   }
  188.  /**
  189.   * Converts a cache key to a full path.
  190.   *
  191.   * @param string $key The cache key
  192.   *
  193.   * @return string The full path to the cache file
  194.   */
  195.   protected function getFilePath($key)
  196.   {
  197.     return $this->getOption('cache_dir').DIRECTORY_SEPARATOR.str_replace(sfCache::SEPARATOR, DIRECTORY_SEPARATOR, $key).self::EXTENSION;
  198.   }
  200.  /**
  201.   * Reads the cache file and returns the content.
  202.   *
  203.   * @param string $path The file path
  204.   * @param mixed  $type The type of data you want to be returned
  205.   *                     sfFileCache::READ_DATA: The cache content
  206.   *                     sfFileCache::READ_TIMEOUT: The timeout
  207.   *                     sfFileCache::READ_LAST_MODIFIED: The last modification timestamp
  208.   *
  209.   * @return array the (meta)data of the cache file. E.g. $data[sfFileCache::READ_DATA]
  210.   *
  211.   * @throws sfCacheException
  212.   */
  213.   protected function read($path, $type = self::READ_DATA)
  214.   {
  215.     if (!$fp = @fopen($path, 'rb'))
  216.     {
  217.       throw new sfCacheException(sprintf('Unable to read cache file "%s".', $path));
  218.     }
  220.     @flock($fp, LOCK_SH);
  221.     $data[self::READ_TIMEOUT] = intval(@stream_get_contents($fp, 12, 0));
  222.     if ($type != self::READ_TIMEOUT && time() < $data[self::READ_TIMEOUT])
  223.     {
  224.       if ($type & self::READ_LAST_MODIFIED)
  225.       {
  226.         $data[self::READ_LAST_MODIFIED] = intval(@stream_get_contents($fp, 12, 12));
  227.       }
  228.       if ($type & self::READ_DATA)
  229.       {
  230.         fseek($fp, 0, SEEK_END);
  231.         $length = ftell($fp) - 24;
  232.         fseek($fp, 24);
  233.         $data[self::READ_DATA] = @fread($fp, $length);
  234.       }
  235.     }
  236.     else
  237.     {
  238.       $data[self::READ_LAST_MODIFIED] = null;
  239.       $data[self::READ_DATA] = null;
  240.     }
  241.     @flock($fp, LOCK_UN);
  242.     @fclose($fp);
  244.     return $data;
  245.   }
  247.  /**
  248.   * Writes the given data in the cache file.
  249.   *
  250.   * @param string  $path    The file path
  251.   * @param string  $data    The data to put in cache
  252.   * @param integer $timeout The timeout timestamp
  253.   *
  254.   * @return boolean true if ok, otherwise false
  255.   *
  256.   * @throws sfCacheException
  257.   */
  258.   protected function write($path, $data, $timeout)
  259.   {
  260.     $current_umask = umask();
  261.     umask(0000);
  263.     if (!is_dir(dirname($path)))
  264.     {
  265.       // create directory structure if needed
  266.       mkdir(dirname($path), 0777, true);
  267.     }
  269.     $tmpFile = tempnam(dirname($path), basename($path));
  271.     if (!$fp = @fopen($tmpFile, 'wb'))
  272.     {
  273.        throw new sfCacheException(sprintf('Unable to write cache file "%s".', $tmpFile));
  274.     }
  276.     @fwrite($fp, str_pad($timeout, 12, 0, STR_PAD_LEFT));
  277.     @fwrite($fp, str_pad(time(), 12, 0, STR_PAD_LEFT));
  278.     @fwrite($fp, $data);
  279.     @fclose($fp);
  281.     // Hack from Agavi (http://trac.agavi.org/changeset/3979)
  282.     // With php < 5.2.6 on win32, renaming to an already existing file doesn't work, but copy does,
  283.     // so we simply assume that when rename() fails that we are on win32 and try to use copy()
  284.     if (!@rename($tmpFile, $path))
  285.     {
  286.       if (copy($tmpFile, $path))
  287.       {
  288.         unlink($tmpFile);
  289.       }
  290.     }
  292.     chmod($path, 0666);
  293.     umask($current_umask);
  295.     return true;
  296.   }
  298.   /**
  299.    * Sets the cache root directory.
  300.    *
  301.    * @param string $cache_dir The directory where to put the cache files
  302.    */
  303.   protected function setcache_dir($cache_dir)
  304.   {
  305.     // remove last DIRECTORY_SEPARATOR
  306.     if (DIRECTORY_SEPARATOR == substr($cache_dir, -1))
  307.     {
  308.       $cache_dir = substr($cache_dir, 0, -1);
  309.     }
  311.     // create cache dir if needed
  312.     if (!is_dir($cache_dir))
  313.     {
  314.       $current_umask = umask(0000);
  315.       @mkdir($cache_dir, 0777, true);
  316.       umask($current_umask);
  317.     }
  318.   }
  319. }
Debug toolbar