vendor/zf1/zend-search-lucene/library/Zend/Search/Lucene/Storage/Directory/Filesystem.php line 190

Open in your IDE?
  1. <?php
  2. /**
  3.  * Zend Framework
  4.  *
  5.  * LICENSE
  6.  *
  7.  * This source file is subject to the new BSD license that is bundled
  8.  * with this package in the file LICENSE.txt.
  9.  * It is also available through the world-wide-web at this URL:
  10.  * http://framework.zend.com/license/new-bsd
  11.  * If you did not receive a copy of the license and are unable to
  12.  * obtain it through the world-wide-web, please send an email
  13.  * to license@zend.com so we can send you a copy immediately.
  14.  *
  15.  * @category   Zend
  16.  * @package    Zend_Search_Lucene
  17.  * @subpackage Storage
  18.  * @copyright  Copyright (c) 2005-2015 Zend Technologies USA Inc. (http://www.zend.com)
  19.  * @license    http://framework.zend.com/license/new-bsd     New BSD License
  20.  * @version    $Id$
  21.  */
  24. /** Zend_Search_Lucene_Storage_Directory */
  25. // require_once 'Zend/Search/Lucene/Storage/Directory.php';
  28. /**
  29.  * FileSystem implementation of Directory abstraction.
  30.  *
  31.  * @category   Zend
  32.  * @package    Zend_Search_Lucene
  33.  * @subpackage Storage
  34.  * @copyright  Copyright (c) 2005-2015 Zend Technologies USA Inc. (http://www.zend.com)
  35.  * @license    http://framework.zend.com/license/new-bsd     New BSD License
  36.  */
  37. class Zend_Search_Lucene_Storage_Directory_Filesystem extends Zend_Search_Lucene_Storage_Directory
  38. {
  39.     /**
  40.      * Filesystem path to the directory
  41.      *
  42.      * @var string
  43.      */
  44.     protected $_dirPath = null;
  46.     /**
  47.      * Cache for Zend_Search_Lucene_Storage_File_Filesystem objects
  48.      * Array: filename => Zend_Search_Lucene_Storage_File object
  49.      *
  50.      * @var array
  51.      * @throws Zend_Search_Lucene_Exception
  52.      */
  53.     protected $_fileHandlers;
  55.     /**
  56.      * Default file permissions
  57.      *
  58.      * @var integer
  59.      */
  60.     protected static $_defaultFilePermissions = 0666;
  63.     /**
  64.      * Get default file permissions
  65.      *
  66.      * @return integer
  67.      */
  68.     public static function getDefaultFilePermissions()
  69.     {
  70.         return self::$_defaultFilePermissions;
  71.     }
  73.     /**
  74.      * Set default file permissions
  75.      *
  76.      * @param integer $mode
  77.      */
  78.     public static function setDefaultFilePermissions($mode)
  79.     {
  80.         self::$_defaultFilePermissions = $mode;
  81.     }
  84.     /**
  85.      * Utility function to recursive directory creation
  86.      *
  87.      * @param string $dir
  88.      * @param integer $mode
  89.      * @param boolean $recursive
  90.      * @return boolean
  91.      */
  93.     public static function mkdirs($dir, $mode = 0775, $recursive = true)
  94.     {
  95.         $mode = $mode & ~0002;
  97.         if (($dir === null) || $dir === '') {
  98.             return false;
  99.         }
  100.         if (is_dir($dir) || $dir === '/') {
  101.             return true;
  102.         }
  103.         if (self::mkdirs(dirname($dir), $mode, $recursive)) {
  104.             return mkdir($dir, $mode);
  105.         }
  106.         return false;
  107.     }
  110.     /**
  111.      * Object constructor
  112.      * Checks if $path is a directory or tries to create it.
  113.      *
  114.      * @param string $path
  115.      * @throws Zend_Search_Lucene_Exception
  116.      */
  117.     public function __construct($path)
  118.     {
  119.         if (!is_dir($path)) {
  120.             if (file_exists($path)) {
  121.                 // require_once 'Zend/Search/Lucene/Exception.php';
  122.                 throw new Zend_Search_Lucene_Exception('Path exists, but it\'s not a directory');
  123.             } else {
  124.                 if (!self::mkdirs($path)) {
  125.                     // require_once 'Zend/Search/Lucene/Exception.php';
  126.                     throw new Zend_Search_Lucene_Exception("Can't create directory '$path'.");
  127.                 }
  128.             }
  129.         }
  130.         $this->_dirPath = $path;
  131.         $this->_fileHandlers = array();
  132.     }
  135.     /**
  136.      * Closes the store.
  137.      *
  138.      * @return void
  139.      */
  140.     public function close()
  141.     {
  142.         foreach ($this->_fileHandlers as $fileObject) {
  143.             $fileObject->close();
  144.         }
  146.         $this->_fileHandlers = array();
  147.     }
  150.     /**
  151.      * Returns an array of strings, one for each file in the directory.
  152.      *
  153.      * @return array
  154.      */
  155.     public function fileList()
  156.     {
  157.         $result = array();
  159.         $dirContent = opendir( $this->_dirPath );
  160.         while (($file = readdir($dirContent)) !== false) {
  161.             if (($file == '..')||($file == '.'))   continue;
  163.             if( !is_dir($this->_dirPath . '/' . $file) ) {
  164.                 $result[] = $file;
  165.             }
  166.         }
  167.         closedir($dirContent);
  169.         return $result;
  170.     }
  172.     /**
  173.      * Creates a new, empty file in the directory with the given $filename.
  174.      *
  175.      * @param string $filename
  176.      * @return Zend_Search_Lucene_Storage_File
  177.      * @throws Zend_Search_Lucene_Exception
  178.      */
  179.     public function createFile($filename)
  180.     {
  181.         if (isset($this->_fileHandlers[$filename])) {
  182.             $this->_fileHandlers[$filename]->close();
  183.         }
  184.         unset($this->_fileHandlers[$filename]);
  185.         // require_once 'Zend/Search/Lucene/Storage/File/Filesystem.php';
  186.         $this->_fileHandlers[$filename] = new Zend_Search_Lucene_Storage_File_Filesystem($this->_dirPath . '/' . $filename, 'w+b');
  188.         // Set file permissions, but don't care about any possible failures, since file may be already
  189.         // created by anther user which has to care about right permissions
  190.         @chmod($this->_dirPath . '/' . $filename, self::$_defaultFilePermissions);
  192.         return $this->_fileHandlers[$filename];
  193.     }
  196.     /**
  197.      * Removes an existing $filename in the directory.
  198.      *
  199.      * @param string $filename
  200.      * @return void
  201.      * @throws Zend_Search_Lucene_Exception
  202.      */
  203.     public function deleteFile($filename)
  204.     {
  205.         if (isset($this->_fileHandlers[$filename])) {
  206.             $this->_fileHandlers[$filename]->close();
  207.         }
  208.         unset($this->_fileHandlers[$filename]);
  210.         global $php_errormsg;
  211.         $trackErrors = ini_get('track_errors');
  212.         ini_set('track_errors', '1');
  213.         if (!@unlink($this->_dirPath . '/' . $filename)) {
  214.             ini_set('track_errors', $trackErrors);
  215.             // require_once 'Zend/Search/Lucene/Exception.php';
  216.             throw new Zend_Search_Lucene_Exception('Can\'t delete file: ' . $php_errormsg);
  217.         }
  218.         ini_set('track_errors', $trackErrors);
  219.     }
  221.     /**
  222.      * Purge file if it's cached by directory object
  223.      *
  224.      * Method is used to prevent 'too many open files' error
  225.      *
  226.      * @param string $filename
  227.      * @return void
  228.      */
  229.     public function purgeFile($filename)
  230.     {
  231.         if (isset($this->_fileHandlers[$filename])) {
  232.             $this->_fileHandlers[$filename]->close();
  233.         }
  234.         unset($this->_fileHandlers[$filename]);
  235.     }
  238.     /**
  239.      * Returns true if a file with the given $filename exists.
  240.      *
  241.      * @param string $filename
  242.      * @return boolean
  243.      */
  244.     public function fileExists($filename)
  245.     {
  246.         return isset($this->_fileHandlers[$filename]) ||
  247.                file_exists($this->_dirPath . '/' . $filename);
  248.     }
  251.     /**
  252.      * Returns the length of a $filename in the directory.
  253.      *
  254.      * @param string $filename
  255.      * @return integer
  256.      */
  257.     public function fileLength($filename)
  258.     {
  259.         if (isset( $this->_fileHandlers[$filename] )) {
  260.             return $this->_fileHandlers[$filename]->size();
  261.         }
  262.         return filesize($this->_dirPath .'/'. $filename);
  263.     }
  266.     /**
  267.      * Returns the UNIX timestamp $filename was last modified.
  268.      *
  269.      * @param string $filename
  270.      * @return integer
  271.      */
  272.     public function fileModified($filename)
  273.     {
  274.         return filemtime($this->_dirPath .'/'. $filename);
  275.     }
  278.     /**
  279.      * Renames an existing file in the directory.
  280.      *
  281.      * @param string $from
  282.      * @param string $to
  283.      * @return void
  284.      * @throws Zend_Search_Lucene_Exception
  285.      */
  286.     public function renameFile($from, $to)
  287.     {
  288.         global $php_errormsg;
  290.         if (isset($this->_fileHandlers[$from])) {
  291.             $this->_fileHandlers[$from]->close();
  292.         }
  293.         unset($this->_fileHandlers[$from]);
  295.         if (isset($this->_fileHandlers[$to])) {
  296.             $this->_fileHandlers[$to]->close();
  297.         }
  298.         unset($this->_fileHandlers[$to]);
  300.         if (file_exists($this->_dirPath . '/' . $to)) {
  301.             if (!unlink($this->_dirPath . '/' . $to)) {
  302.                 // require_once 'Zend/Search/Lucene/Exception.php';
  303.                 throw new Zend_Search_Lucene_Exception('Delete operation failed');
  304.             }
  305.         }
  307.         $trackErrors = ini_get('track_errors');
  308.         ini_set('track_errors', '1');
  310.         $success = @rename($this->_dirPath . '/' . $from, $this->_dirPath . '/' . $to);
  311.         if (!$success) {
  312.             ini_set('track_errors', $trackErrors);
  313.             // require_once 'Zend/Search/Lucene/Exception.php';
  314.             throw new Zend_Search_Lucene_Exception($php_errormsg);
  315.         }
  317.         ini_set('track_errors', $trackErrors);
  319.         return $success;
  320.     }
  323.     /**
  324.      * Sets the modified time of $filename to now.
  325.      *
  326.      * @param string $filename
  327.      * @return void
  328.      */
  329.     public function touchFile($filename)
  330.     {
  331.         return touch($this->_dirPath .'/'. $filename);
  332.     }
  335.     /**
  336.      * Returns a Zend_Search_Lucene_Storage_File object for a given $filename in the directory.
  337.      *
  338.      * If $shareHandler option is true, then file handler can be shared between File Object
  339.      * requests. It speed-ups performance, but makes problems with file position.
  340.      * Shared handler are good for short atomic requests.
  341.      * Non-shared handlers are useful for stream file reading (especial for compound files).
  342.      *
  343.      * @param string $filename
  344.      * @param boolean $shareHandler
  345.      * @return Zend_Search_Lucene_Storage_File
  346.      */
  347.     public function getFileObject($filename, $shareHandler = true)
  348.     {
  349.         $fullFilename = $this->_dirPath . '/' . $filename;
  351.         // require_once 'Zend/Search/Lucene/Storage/File/Filesystem.php';
  352.         if (!$shareHandler) {
  353.             return new Zend_Search_Lucene_Storage_File_Filesystem($fullFilename);
  354.         }
  356.         if (isset( $this->_fileHandlers[$filename] )) {
  357.             $this->_fileHandlers[$filename]->seek(0);
  358.             return $this->_fileHandlers[$filename];
  359.         }
  361.         $this->_fileHandlers[$filename] = new Zend_Search_Lucene_Storage_File_Filesystem($fullFilename);
  362.         return $this->_fileHandlers[$filename];
  363.     }
  364. }