PHP Zend_Search_Lucene_Storage_Directory类代码示例

 public static function getActualGeneration(Zend_Search_Lucene_Storage_Directory $directory)
 {
     require_once 'Zend/Search/Lucene/Exception.php';
     try {
         for ($count = 0; $count < self::GENERATION_RETRIEVE_COUNT; $count++) {
             // Try to get generation file
             $genFile = $directory->getFileObject('segments.gen', false);
             $format = $genFile->readInt();
             if ($format != (int) 0xfffffffe) {
                 throw new Zend_Search_Lucene_Exception('Wrong segments.gen file format');
             }
             $gen1 = $genFile->readLong();
             $gen2 = $genFile->readLong();
             if ($gen1 == $gen2) {
                 return $gen1;
             }
             usleep(self::GENERATION_RETRIEVE_PAUSE * 1000);
         }
         // All passes are failed
         throw new Zend_Search_Lucene_Exception('Index is under processing now');
     } catch (Zend_Search_Lucene_Exception $e) {
         if (strpos($e->getMessage(), 'is not readable') !== false) {
             try {
                 // Try to open old style segments file
                 $segmentsFile = $directory->getFileObject('segments', false);
                 // It's pre-2.1 index
                 return 0;
             } catch (Zend_Search_Lucene_Exception $e) {
                 if (strpos($e->getMessage(), 'is not readable') !== false) {
                     return -1;
                 } else {
                     throw $e;
                 }
             }
         } else {
             throw $e;
         }
     }
     return -1;
 }

 public static function createIndex(Zend_Search_Lucene_Storage_Directory $directory, $generation, $nameCount)
 {
     if ($generation == 0) {
         // Create index in pre-2.1 mode
         foreach ($directory->fileList() as $file) {
             if ($file == 'deletable' || $file == 'segments' || isset(self::$_indexExtensions[substr($file, strlen($file) - 4)]) || preg_match('/\\.f\\d+$/i', $file)) {
                 $directory->deleteFile($file);
             }
         }
         $segmentsFile = $directory->createFile('segments');
         $segmentsFile->writeInt((int) 0xffffffff);
         // write version (is initialized by current time
         // $segmentsFile->writeLong((int)microtime(true));
         $version = microtime(true);
         $segmentsFile->writeInt((int) ($version / ((double) 0xffffffff + 1)));
         $segmentsFile->writeInt((int) ($version & 0xffffffff));
         // write name counter
         $segmentsFile->writeInt($nameCount);
         // write segment counter
         $segmentsFile->writeInt(0);
         $deletableFile = $directory->createFile('deletable');
         // write counter
         $deletableFile->writeInt(0);
     } else {
         $genFile = $directory->createFile('segments.gen');
         $genFile->writeInt((int) 0xfffffffe);
         // Write generation two times
         $genFile->writeLong($generation);
         $genFile->writeLong($generation);
         $segmentsFile = $directory->createFile(Zend_Search_Lucene::getSegmentFileName($generation));
         $segmentsFile->writeInt((int) 0xfffffffd);
         // write version (is initialized by current time
         // $segmentsFile->writeLong((int)microtime(true));
         $version = microtime(true);
         $segmentsFile->writeInt((int) ($version / ((double) 0xffffffff + 1)));
         $segmentsFile->writeInt((int) ($version & 0xffffffff));
         // write name counter
         $segmentsFile->writeInt($nameCount);
         // write segment counter
         $segmentsFile->writeInt(0);
     }
 }

 /**
  * Release exclusive optimization lock
  *
  * @param Zend_Search_Lucene_Storage_Directory $lockDirectory
  */
 public static function releaseOptimizationLock(Zend_Search_Lucene_Storage_Directory $lockDirectory)
 {
     $lock = $lockDirectory->getFileObject(self::OPTIMIZATION_LOCK_FILE);
     $lock->unlock();
 }

 /**
  * Release exclusive optimization lock
  * 
  * @param Zend_Search_Lucene_Storage_Directory $lockDirectory
  */
 public static function releaseOptimizationLock(Zend_Search_Lucene_Storage_Directory $lockDirectory)
 {
     $lockDirectory->deleteFile(self::OPTIMIZATION_LOCK_FILE);
 }

 public static function getActualGeneration(Zend_Search_Lucene_Storage_Directory $directory)
 {
     try {
         for ($count = 0; $count < self::GENERATION_RETRIEVE_COUNT; $count++) {
             $genFile = $directory->getFileObject('segments.gen', false);
             $format = $genFile->readInt();
             if ($format != (int) 0xfffffffe) {
                 throw new Zend_Search_Lucene_Exception('Wrong segments.gen file format');
             }
             $gen1 = $genFile->readLong();
             $gen2 = $genFile->readLong();
             if ($gen1 == $gen2) {
                 return $gen1;
             }
             usleep(self::GENERATION_RETRIEVE_PAUSE * 1000);
         }
         throw new Zend_Search_Lucene_Exception('Index is under processing now');
     } catch (Zend_Search_Lucene_Exception $e) {
         if (strpos($e->getMessage(), 'is not readable') !== false) {
             try {
                 $segmentsFile = $directory->getFileObject('segments', false);
                 return 0;
             } catch (Zend_Search_Lucene_Exception $e) {
                 if (strpos($e->getMessage(), 'is not readable') !== false) {
                     return -1;
                 } else {
                     throw new Zend_Search_Lucene_Exception($e->getMessage(), $e->getCode(), $e);
                 }
             }
         } else {
             throw new Zend_Search_Lucene_Exception($e->getMessage(), $e->getCode(), $e);
         }
     }
     return -1;
 }

 /**
  * Object destructor
  */
 public function __destruct()
 {
     $this->commit();
     if ($this->_closeDirOnExit) {
         $this->_directory->close();
     }
 }

 /**
  * Generate compound index file
  */
 protected function _generateCFS()
 {
     $cfsFile = $this->_directory->createFile($this->_name . '.cfs');
     $cfsFile->writeVInt(count($this->_files));
     $dataOffsetPointers = array();
     foreach ($this->_files as $fileName) {
         $dataOffsetPointers[$fileName] = $cfsFile->tell();
         $cfsFile->writeLong(0);
         // write dummy data
         $cfsFile->writeString($fileName);
     }
     foreach ($this->_files as $fileName) {
         // Get actual data offset
         $dataOffset = $cfsFile->tell();
         // Seek to the data offset pointer
         $cfsFile->seek($dataOffsetPointers[$fileName]);
         // Write actual data offset value
         $cfsFile->writeLong($dataOffset);
         // Seek back to the end of file
         $cfsFile->seek($dataOffset);
         $dataFile = $this->_directory->getFileObject($fileName);
         $byteCount = $this->_directory->fileLength($fileName);
         while ($byteCount > 0) {
             $data = $dataFile->readBytes(min($byteCount, 131072));
             $byteCount -= strlen($data);
             $cfsFile->writeBytes($data);
         }
         $this->_directory->deleteFile($fileName);
     }
 }

 /**
  * Object destructor
  */
 public function __destruct()
 {
     $this->commit();
     // Free shared lock
     $this->_lock->unlock();
     if ($this->_closeDirOnExit) {
         $this->_directory->close();
     }
 }

 /**
  * Close current index and free resources
  *
  * @internal
  */
 public function close()
 {
     $this->commit();
     // Free shared lock
     $this->_lock->unlock();
     if ($this->_closeDirOnExit) {
         $this->_directory->close();
     }
     $this->_directory = null;
     $this->_writer = null;
     $this->_segmentInfos = null;
 }

 /**
  * Close current index and free resources
  */
 private function _close()
 {
     if ($this->_closed) {
         // index is already closed and resources are cleaned up
         return;
     }
     $this->commit();
     if ($this->_closeDirOnExit) {
         $this->_directory->close();
     }
     $this->_directory = null;
     $this->_writer = null;
     $this->_segmentInfos = null;
     $this->_closed = true;
 }

 /**
  * Update segments file by adding current segment to a list
  * @todo !!!!!Finish the implementation
  *
  * @throws Zend_Search_Lucene_Exception
  */
 private function _updateSegments()
 {
     $segmentsFile = $this->_directory->getFileObject('segments');
     $newSegmentFile = $this->_directory->createFile('segments.new');
     $newSegmentFile->writeInt((int) 0xffffffff);
     $newSegmentFile->writeLong($this->_version);
     $newSegmentFile->writeInt($this->_segmentNameCounter);
     $newSegmentFile->writeInt($this->_segments + count($this->_newSegments));
     $segmentsFile->seek(20);
     $newSegmentFile->writeBytes($segmentsFile->readBytes($this->_directory->fileLength('segments') - 20));
     foreach ($this->_newSegments as $segmentName => $segmentInfo) {
         $newSegmentFile->writeString($segmentName);
         $newSegmentFile->writeInt($segmentInfo->count());
     }
     $this->_directory->renameFile('segments.new', 'segments');
 }

 /**
  * Get name for new segment
  *
  * @return string
  */
 private function _newSegmentName()
 {
     Zend_Search_Lucene_LockManager::obtainWriteLock($this->_directory);
     $generation = Zend_Search_Lucene::getActualGeneration($this->_directory);
     $segmentsFile = $this->_directory->getFileObject(Zend_Search_Lucene::getSegmentFileName($generation), false);
     $segmentsFile->seek(12);
     // 12 = 4 (int, file format marker) + 8 (long, index version)
     $segmentNameCounter = $segmentsFile->readInt();
     $segmentsFile->seek(12);
     // 12 = 4 (int, file format marker) + 8 (long, index version)
     $segmentsFile->writeInt($segmentNameCounter + 1);
     // Flash output to guarantee that wrong value will not be loaded between unlock and
     // return (which calls $segmentsFile destructor)
     $segmentsFile->flush();
     Zend_Search_Lucene_LockManager::releaseWriteLock($this->_directory);
     return '_' . base_convert($segmentNameCounter, 10, 36);
 }

 /**
  * Close current index and free resources
  */
 private function _close()
 {
     if ($this->_closed) {
         // index is already closed and resources are cleaned up
         return;
     }
     $this->commit();
     // Release "under processing" flag
     Zend_Search_Lucene_LockManager::releaseReadLock($this->_directory);
     if ($this->_closeDirOnExit) {
         $this->_directory->close();
     }
     $this->_directory = null;
     $this->_writer = null;
     $this->_segmentInfos = null;
     $this->_closed = true;
 }

 /**
  * Close current index and free resources
  *
  * @internal
  */
 public function close()
 {
     if ($this->_closed) {
         // index is already closed and resources are cleaned up
         return;
     }
     $this->commit();
     // Free shared lock
     $this->_lock->unlock();
     if ($this->_closeDirOnExit) {
         $this->_directory->close();
     }
     $this->_directory = null;
     $this->_writer = null;
     $this->_segmentInfos = null;
     $this->_closed = true;
 }

 /**
  * Get name for new segment
  *
  * @return string
  */
 private function _newSegmentName()
 {
     // Do not share file handler to get file updates from other sessions.
     $segmentsFile = $this->_directory->getFileObject('segments', false);
     // Get exclusive segments file lock
     // We have guarantee, that we will not intersect with _updateSegments() call
     // of other process, because it needs exclusive index lock and waits
     // until all other searchers won't stop
     if (!$segmentsFile->lock(LOCK_EX)) {
         throw new Zend_Search_Lucene_Exception('Can\'t obtain exclusive index lock');
     }
     $segmentsFile->seek(12);
     // 12 = 4 (int, file format marker) + 8 (long, index version)
     $segmentNameCounter = $segmentsFile->readInt();
     $segmentsFile->seek(12);
     // 12 = 4 (int, file format marker) + 8 (long, index version)
     $segmentsFile->writeInt($segmentNameCounter + 1);
     // Flash output to guarantee that wrong value will not be loaded between unlock and
     // return (which calls $segmentsFile destructor)
     $segmentsFile->flush();
     $segmentsFile->unlock();
     return '_' . base_convert($segmentNameCounter, 10, 36);
 }