home *** CD-ROM | disk | FTP | other *** search
/ PC World 2001 August / PCWorld_2001-08_cd.bin / Komunikace / phptriad / phptriadsetup2-11.exe / php / pear / Cache / Container / file.php < prev    next >
PHP Script  |  2001-03-23  |  10KB  |  275 lines
  1. <?php
  2. // +----------------------------------------------------------------------+
  3. // | PHP version 4.0                                                      |
  4. // +----------------------------------------------------------------------+
  5. // | Copyright (c) 1997, 1998, 1999, 2000, 2001 The PHP Group             |
  6. // +----------------------------------------------------------------------+
  7. // | This source file is subject to version 2.0 of the PHP license,       |
  8. // | that is bundled with this package in the file LICENSE, and is        |
  9. // | available at through the world-wide-web at                           |
  10. // | http://www.php.net/license/2_02.txt.                                 |
  11. // | If you did not receive a copy of the PHP license and are unable to   |
  12. // | obtain it through the world-wide-web, please send a note to          |
  13. // | license@php.net so we can mail you a copy immediately.               |
  14. // +----------------------------------------------------------------------+
  15. // | Authors: Ulf Wendel <ulf.wendel@phpdoc.de>                           |
  16. // |          Sebastian Bergmann <sb@sebastian-bergmann.de>               |
  17. // +----------------------------------------------------------------------+
  18. //
  19. // $Id: file.php,v 1.8.2.1 2001/03/23 18:35:17 chregu Exp $
  20.  
  21. require_once 'Cache/Container.php';
  22.  
  23. /**
  24. * Stores cache contents in a file.
  25. *
  26. * @author   Ulf Wendel  <ulf.wendel@phpdoc.de>
  27. * @version  $Id: file.php,v 1.8.2.1 2001/03/23 18:35:17 chregu Exp $
  28. */
  29. class Cache_Container_file extends Cache_Container {
  30.  
  31.     /**
  32.     * Directory where to put the cache files.
  33.     *
  34.     * @var  string  Make sure to add a trailing slash
  35.     */
  36.     var $cache_dir = "";
  37.  
  38.     /**
  39.     * Filename prefix for cache files.
  40.     *
  41.     * You can use the filename prefix to implement a "domain" based cache or just
  42.     * to give the files a more descriptive name. The word "domain" is borroed from
  43.     * a user authentification system. One user id (cached dataset with the ID x)
  44.     * may exists in different domains (different filename prefix). You might want
  45.     * to use this to have different cache values for a production, development and
  46.     * quality assurance system. If you want the production cache not to be influenced
  47.     * by the quality assurance activities, use different filename prefixes for them.
  48.     *
  49.     * I personally don't think that you'll never need this, but 640kb happend to be
  50.     * not enough, so... you know what I mean. If you find a useful application of the
  51.     * feature please update this inline doc.
  52.     *
  53.     * @var  string
  54.     */
  55.     var $filename_prefix = "";
  56.  
  57.     /**
  58.     * Creates the cache directory if neccessary
  59.     *
  60.     * @param    array   Config options: ["cache_dir" => ..., "filename_prefix" => ...]
  61.     */
  62.     function Cache_Container_file($options = "") {
  63.         if (is_array($options))
  64.             $this->setOptions($options, array("cache_dir", "filename_prefix"));
  65.  
  66.         clearstatcache();
  67.  
  68.         //make relative paths absolute for use in deconstructor.
  69.         // it looks like the deconstructor has problems with relative paths
  70.         if (preg_match("/\.+/",$this->cache_dir))
  71.             $this->cache_dir=realpath(getcwd()."/".$this->cache_dir)."/";
  72.  
  73.         if (!file_exists($this->cache_dir) || !is_dir($this->cache_dir))
  74.             mkdir($this->cache_dir, 0755);
  75.     } // end func contructor
  76.  
  77.     function fetch($id, $group) {
  78.         $file = $this->getFilename($id, $group);
  79.         if (!file_exists($file))
  80.             return array(NULL, NULL, NULL);
  81.  
  82.         // retrive the content
  83.         if (!($fh = @fopen($file, "rb")))
  84.             return new Cache_Error("Can't access cache file '$file'. Check access rights and path.", __FILE__, __LINE__);
  85.  
  86.         // file format:
  87.         // 1st line: expiration date
  88.         // 2nd line: user data
  89.         // 3rd+ lines: cache data
  90.         $expire = trim(fgets($fh, 11));
  91.         $userdata = trim(fgets($fh, 257));
  92.         $cachedata = $this->decode(fread($fh, filesize($file)));
  93.         fclose($fh);
  94.  
  95.         return array($expire, $cachedata, $userdata);
  96.     } // end func fetch
  97.  
  98.     /**
  99.     * Stores a dataset.
  100.     *
  101.     * WARNING: If you supply userdata it must not contain any linebreaks,
  102.     * otherwise it will break the filestructure.
  103.     */
  104.     function save($id, $cachedata, $expires, $group, $userdata) {
  105.         $this->flushPreload($id, $group);
  106.  
  107.         $file = $this->getFilename($id, $group);
  108.         if (!($fh = @fopen($file, "wb")))
  109.             return new Cache_Error("Can't access '$file' to store cache data. Check access rights and path.", __FILE__, __LINE__);
  110.  
  111.         // file format:
  112.         // 1st line: expiration date
  113.         // 2nd line: user data
  114.         // 3rd+ lines: cache data
  115.         $expires = $this->getExpiresAbsolute($expires);
  116.         fwrite($fh, $expires . "\n");
  117.         fwrite($fh, $userdata . "\n");
  118.         fwrite($fh, $this->encode($cachedata));
  119.  
  120.         fclose($fh);
  121.  
  122.         // I'm not sure if we need this
  123.         touch($file);
  124.  
  125.         return true;
  126.     } // end func save
  127.  
  128.     function delete($id, $group) {
  129.         $this->flushPreload($id, $group);
  130.  
  131.         $file = $this->getFilename($id, $group);
  132.         if (file_exists($file)) {
  133.  
  134.             $ok = unlink($file);
  135.             clearstatcache();
  136.  
  137.             return $ok;
  138.         }
  139.  
  140.         return false;
  141.     } // end func delete
  142.  
  143.     function flush($group) {
  144.         $this->flushPreload();
  145.         $dir = ($group) ? $this->cache_dir . $group . "/" : $this->cache_dir;
  146.  
  147.         $num_removed = $this->deleteDir($dir);
  148.         clearstatcache();
  149.  
  150.         return $num_removed;
  151.     } // end func flush
  152.  
  153.     function idExists($id, $group) {
  154.         return file_exists($this->getFilename($id, $group));
  155.  
  156.     } // end func idExists
  157.  
  158.     /**
  159.     * Deletes all expired files.
  160.     *
  161.     * Garbage collection for files is a rather "expensive", "long time"
  162.     * operation. All files in the cache directory have to be examined which
  163.     * means that they must be opened for reading, the expiration date has to be
  164.     * read from them and if neccessary they have to be unlinked (removed).
  165.     * If you have a user comment for a good default gc probability please add it to
  166.     * to the inline docs.
  167.     *
  168.     * @param    string  directory to examine - don't sets this parameter, it's used for a
  169.     *                   recursive function call!
  170.     */
  171.     function garbageCollection($dir = "") {
  172.         $this->flushPreload();
  173.  
  174.         if (!$dir)
  175.             $dir = $this->cache_dir;
  176.  
  177.         if (!($dh = opendir($dir)))
  178.             return new Cache_Error("Can't access cache directory '$dir'. Check permissions and path.", __FILE__, __LINE__);
  179.  
  180.         while ($file = readdir($dh)) {
  181.             if ("." == $file || ".." == $file)
  182.                 continue;
  183.  
  184.             $file = $dir . $file;
  185.             if (is_dir($file)) {
  186.                 $this->garbageCollection($file . "/");
  187.                 continue;
  188.             }
  189.  
  190.             // skip trouble makers but inform the user
  191.             if (!($fh = @fopen($file, "rb"))) {
  192.                 new Cache_Error("Can't access cache file '$file', skipping it. Check permissions and path.", __FILE__, __LINE__);
  193.                 continue;
  194.             }
  195.  
  196.             $expire = fgets($fh, 11);
  197.             fclose($fh);
  198.  
  199.             // remove if expired
  200.             if ($expire && $expire <= time() && !unlink($file))
  201.                 new Cache_Error("Can't unlink cache file '$file', skipping. Check permissions and path.", __FILE__, __LINE__);
  202.         }
  203.  
  204.         closedir($dh);
  205.  
  206.         // flush the disk state cache
  207.         clearstatcache();
  208.     } // end func garbageCollection
  209.  
  210.     /**
  211.     * Returns the filename for the specified id.
  212.     *
  213.     * @param    string  dataset ID
  214.     * @param    string  cache group
  215.     * @return   string  full filename with the path
  216.     * @access   public
  217.     */
  218.     function getFilename($id, $group) {
  219.         static $group_dirs = array();
  220.  
  221.         if (isset($group_dirs[$group]))
  222.             return $group_dirs[$group] . $this->filename_prefix . $id;
  223.  
  224.         $dir = $this->cache_dir . $group . "/";
  225.         if (!file_exists($dir)) {
  226.             mkdir($dir, 0755);
  227.             clearstatcache();
  228.         }
  229.  
  230.         $group_dirs[$group] = $dir;
  231.  
  232.         return $dir . $this->filename_prefix . $id;
  233.     } // end func getFilename
  234.  
  235.     /**
  236.     * Deletes a directory and all files in it.
  237.     *
  238.     * @param    string  directory
  239.     * @return   integer number of removed files
  240.     * @throws   Cache_Error
  241.     */
  242.     function deleteDir($dir) {
  243.         if (!($dh = opendir($dir)))
  244.             return new Cache_Error("Can't remove directory '$dir'. Check permissions and path.", __FILE__, __LINE__);
  245.  
  246.         $num_removed = 0;
  247.  
  248.         while ($file = readdir($dh)) {
  249.             if ("." == $file || ".." == $file)
  250.                 continue;
  251.  
  252.             $file = $dir . $file;
  253.             if (is_dir($file)) {
  254.                 $file .= "/";
  255.                 $num = $this->deleteDir($file . "/");
  256.                 if (is_int($num))
  257.                     $num_removed += $num;
  258.             } else {
  259.                 if (unlink($file))
  260.                     $num_removed++;
  261.             }
  262.         }
  263.         // according to php-manual the following is needed for windows installations.
  264.         closedir($dh);
  265.         unset( $dh);
  266.         if ($dir != $this->cache_dir) {  //delete the sub-dir entries  itself also, but not the cache-dir.
  267.             rmDir($dir);
  268.             $num_removed++;
  269.         }
  270.  
  271.         return $num_removed;
  272.     } // end func deleteDir
  273. } // end class file
  274. ?>
  275.