writer.php

来自「PHP 知识管理系统（基于树结构的知识管理系统）, 英文原版的PHP源码。」· PHP 代码 · 共 507 行 · 第 1/2 页

                $sizeToMerge *= $this->mergeFactor;

                if ($sizeToMerge > $this->maxMergeDocs) {
                    return;
                }
            }

            $mergePool[] = $this->_segmentInfos[$segId];
            $poolSize += $size;
        }

        if ($poolSize >= $sizeToMerge) {
            $this->_mergeSegments($mergePool);
        }
    }

    /**
     * Merge specified segments
     *
     * $segments is an array of SegmentInfo objects
     *
     * @param array $segments
     */
    private function _mergeSegments($segments)
    {
        // Try to get exclusive non-blocking lock to the 'index.optimization.lock'
        // Skip optimization if it's performed by other process right now
        $optimizationLock = $this->_directory->createFile('index.optimization.lock');
        if (!$optimizationLock->lock(LOCK_EX,true)) {
            return;
        }

        $newName = $this->_newSegmentName();
        $merger = new Zend_Search_Lucene_Index_SegmentMerger($this->_directory,
                                                             $newName);
        foreach ($segments as $segmentInfo) {
            $merger->addSource($segmentInfo);
            $this->_segmentsToDelete[$segmentInfo->getName()] = $segmentInfo->getName();
        }

        $newSegment = $merger->merge();
        if ($newSegment !== null) {
            $this->_newSegments[$newSegment->getName()] = $newSegment;
        }

        $this->commit();

        // optimization is finished
        $optimizationLock->unlock();
    }

    /**
     * Update segments file by adding current segment to a list
     *
     * @throws Zend_Search_Lucene_Exception
     */
    private function _updateSegments()
    {
        // Get an exclusive index lock
        // Wait, until all parallel searchers or indexers won't stop
        // and stop all next searchers, while we are updating segments file
        $lock = $this->_directory->getFileObject('index.lock');
        if (!$lock->lock(LOCK_EX)) {
            throw new Zend_Search_Lucene_Exception('Can\'t obtain exclusive index lock');
        }


        // Do not share file handlers to get file updates from other sessions.
        $segmentsFile   = $this->_directory->getFileObject('segments', false);
        $newSegmentFile = $this->_directory->createFile('segments.new', false);

        // Write format marker
        $newSegmentFile->writeInt((int)0xFFFFFFFF);

        // Write index version
        $segmentsFile->seek(4, SEEK_CUR);
        // $version = $segmentsFile->readLong() + $this->_versionUpdate;
        // Process version on 32-bit platforms
        $versionHigh = $segmentsFile->readInt();
        $versionLow  = $segmentsFile->readInt();
        $version = $versionHigh * ((double)0xFFFFFFFF + 1) +
                   (($versionLow < 0)? (double)0xFFFFFFFF - (-1 - $versionLow) : $versionLow);
        $version += $this->_versionUpdate;
        $this->_versionUpdate = 0;
        $newSegmentFile->writeInt((int)($version/((double)0xFFFFFFFF + 1)));
        $newSegmentFile->writeInt((int)($version & 0xFFFFFFFF));

        // Write segment name counter
        $newSegmentFile->writeInt($segmentsFile->readInt());

        // Get number of segments offset
        $numOfSegmentsOffset = $newSegmentFile->tell();
        // Write number of segemnts
        $segmentsCount = $segmentsFile->readInt();
        $newSegmentFile->writeInt(0);  // Write dummy data (segment counter)

        $segments = array();
        for ($count = 0; $count < $segmentsCount; $count++) {
            $segName = $segmentsFile->readString();
            $segSize = $segmentsFile->readInt();

            if (!in_array($segName, $this->_segmentsToDelete)) {
                $newSegmentFile->writeString($segName);
                $newSegmentFile->writeInt($segSize);

                $segments[$segName] = $segSize;
            }
        }
        $segmentsFile->close();

        $segmentsCount = count($segments) + count($this->_newSegments);

        // Remove segments, not listed in $segments (deleted)
        // Load segments, not listed in $this->_segmentInfos
        foreach ($this->_segmentInfos as $segId => $segInfo) {
            if (isset($segments[$segInfo->getName()])) {
                // Segment is already included into $this->_segmentInfos
                unset($segments[$segInfo->getName()]);
            } else {
                // remove deleted segment from a list
                unset($this->_segmentInfos[$segId]);
            }
        }
        // $segments contains a list of segments to load
        // do it later

        foreach ($this->_newSegments as $segName => $segmentInfo) {
            $newSegmentFile->writeString($segName);
            $newSegmentFile->writeInt($segmentInfo->count());

            $this->_segmentInfos[] = $segmentInfo;
        }
        $this->_newSegments = array();

        $newSegmentFile->seek($numOfSegmentsOffset);
        $newSegmentFile->writeInt($segmentsCount);  // Update segments count
        $newSegmentFile->close();
        $this->_directory->renameFile('segments.new', 'segments');


        // Segments file update is finished
        // Switch back to shared lock mode
        $lock->lock(LOCK_SH);


        $fileList = $this->_directory->fileList();
        foreach ($this->_segmentsToDelete as $nameToDelete) {
            foreach (self::$_indexExtensions as $ext) {
                if ($this->_directory->fileExists($nameToDelete . $ext)) {
                    $this->_directory->deleteFile($nameToDelete . $ext);
                }
            }

            foreach ($fileList as $file) {
                if (substr($file, 0, strlen($nameToDelete) + 2) == ($nameToDelete . '.f') &&
                    ctype_digit( substr($file, strlen($nameToDelete) + 2) )) {
                        $this->_directory->deleteFile($file);
                    }
            }
        }
        $this->_segmentsToDelete = array();

        // Load segments, created by other process
        foreach ($segments as $segName => $segSize) {
            // Load new segments
            $this->_segmentInfos[] = new Zend_Search_Lucene_Index_SegmentInfo($segName,
                                                                              $segSize,
                                                                              $this->_directory);
        }
    }


    /**
     * Commit current changes
     */
    public function commit()
    {
        if ($this->_currentSegment !== null) {
            $newSegment = $this->_currentSegment->close();
            if ($newSegment !== null) {
                $this->_newSegments[$newSegment->getName()] = $newSegment;
            }
            $this->_currentSegment = null;
        }

        if (count($this->_newSegments)      != 0 ||
            count($this->_segmentsToDelete) != 0) {
            $this->_updateSegments();
        }
    }


    /**
     * Merges the provided indexes into this index.
     *
     * @param array $readers
     * @return void
     */
    public function addIndexes($readers)
    {
        /**
         * @todo implementation
         */
    }

    /**
     * Merges all segments together into a single segment, optimizing
     * an index for search.
     * Input is an array of Zend_Search_Lucene_Index_SegmentInfo objects
     *
     * @throws Zend_Search_Lucene_Exception
     */
    public function optimize()
    {
        $this->_mergeSegments($this->_segmentInfos);
    }

    /**
     * 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);
    }

}