BlogJava-裤衩的天空-文章分类-Lucene研究

Lucene并发连接实现问题

付涛 — Fri, 28 Dec 2007 08:23:00 GMT

import edu.emory.mathcs.backport.java.util.concurrent.atomic.AtomicBoolean;
import edu.emory.mathcs.backport.java.util.concurrent.locks.Lock;
import edu.emory.mathcs.backport.java.util.concurrent.locks.ReentrantLock;
import java.io.File;
import java.io.IOException;
import org.apache.log4j.Logger;
import org.apache.lucene.analysis.Analyzer;
import org.apache.lucene.index.IndexReader;
import org.apache.lucene.index.IndexWriter;
import org.apache.lucene.search.DelayCloseIndexSearcher;
import org.apache.lucene.search.IndexSearcher;
import org.apache.lucene.store.*;

public class ConcurrentLuceneConnection
implements ILuceneConnection
{

private static Logger log;
private transient Directory directory;
private final Analyzer analyzerForIndexing;
private final ILuceneConnection.Configuration configuration;
private final Lock indexWriteLock;
private final Lock searcherCreationLock;
private final AtomicBoolean batchMode;
private DelayCloseIndexSearcher currentSearcher;

public ConcurrentLuceneConnection(Directory directory, Analyzer analyzer, ILuceneConnection.Configuration configuration)
{
     indexWriteLock = new ReentrantLock();
     searcherCreationLock = new ReentrantLock();
     batchMode = new AtomicBoolean(false);
     this.directory = directory;
     analyzerForIndexing = analyzer;
     this.configuration = configuration;
}

public ConcurrentLuceneConnection(File path, Analyzer analyzer, ILuceneConnection.Configuration configuration)
{
     this(getDirectory(path), analyzer, configuration);
}

public int getNumDocs()
{
     return ((Integer)withReader(new ILuceneConnection.ReaderAction() {

         public Object perform(IndexReader reader)
         {
             return new Integer(reader.numDocs());
         }

     })).intValue();
}

public boolean isIndexCreated()
{
try{
     return IndexReader.indexExists(directory);
}catch(IOException e){
     throw new LuceneException(e);
}
}

public IndexSearcher leakSearcher()
{
try{
     return getOpenedSearcher();
}catch(Throwable e){
     flipCurrentSearcher();
     throwLuceneException(e);
     throw new IllegalStateException("Exception should have been thrown.");
}
}

public void optimize()
     throws LuceneException
{
     withWriter(new ILuceneConnection.WriterAction() {

         public void perform(IndexWriter writer)
             throws IOException
         {
             writer.optimize();
         }
     });
}

public void recreateIndexDirectory()
{
     indexWriteLock.lock();
     try
     {
         directory.close();
         if(directory instanceof FSDirectory)
             directory = FSDirectory.getDirectory(((FSDirectory)directory).getFile(), true);
         else
         if(directory instanceof RAMDirectory)
             directory = new RAMDirectory();
         (new IndexWriter(directory, null, true)).close();
     }
     catch(IOException e)
     {
         throw new LuceneException("Cannot create index directory.", e);
     }
     flipCurrentSearcher();
     indexWriteLock.unlock();
}

public void close()
{
     flipCurrentSearcher();
}

public void withSearch(ILuceneConnection.SearcherAction action)
     throws LuceneException
{
try{
     IndexSearcher searcher = getOpenedSearcher();
     boolean b = action.perform(searcher);
     if(!b)
         throw new UnsupportedOperationException("Searchers are always closed. The searcherAction should always return true, we do not allow them to control closing of the searchers");
     closeSearcher(searcher);
}catch(Throwable e){
     flipCurrentSearcher();
     throwLuceneException(e);
}
}

public Object withReader(ILuceneConnection.ReaderAction action)
     throws LuceneException
{
try{
     IndexSearcher searcher = getOpenedSearcher();
     Object obj = action.perform(searcher.getIndexReader());
     closeSearcher(searcher);
     return obj;
}catch(Throwable e){
     flipCurrentSearcher();
     throwLuceneException(e);
     return null;
}
}

public void withReaderAndDeletes(ILuceneConnection.ReaderAction action)
     throws LuceneException
{
     IndexReader deleter;
     indexWriteLock.lock();
     deleter = null;
     try
     {
         deleter = constructIndexDeleter();
         action.perform(deleter);
         flipCurrentSearcher();
     }
     catch(IOException e)
     {
         throw new LuceneException(e);
     }
     closeReader(deleter);
     indexWriteLock.unlock();
}

public void withWriter(ILuceneConnection.WriterAction action)
     throws LuceneException
{
     IndexWriter writer;
     indexWriteLock.lock();
     writer = null;
     try
     {
         writer = constructIndexWriter();
         action.perform(writer);
         flipCurrentSearcher();
     }
     catch(IOException e)
     {
         throw new LuceneException(e);
     }
     closeWriter(writer);
     indexWriteLock.unlock();
}

public void withDeleteAndWrites(ILuceneConnection.ReaderAction readerAction, ILuceneConnection.WriterAction writerAction)
     throws LuceneException
{
     indexWriteLock.lock();
     withReaderAndDeletes(readerAction);
     withWriter(writerAction);
     indexWriteLock.unlock();
}

public void withBatchUpdate(ILuceneConnection.BatchUpdateAction action)
{
try{
     indexWriteLock.lock();
     batchMode.set(true);
     action.perform();
     batchMode.set(false);
     indexWriteLock.unlock();
}catch(Exception e){
throwLuceneException(e);
}
}

public void flipCurrentSearcher()
{
     if(log.isDebugEnabled())
         log.debug("Closing current searcher..");
     searcherCreationLock.lock();
     if(currentSearcher != null)
     {
    try{
     currentSearcher.closeWhenDone();
     currentSearcher = null;
    }catch(Exception e){
    log.error(e);
    currentSearcher = null;
    }
     }
     searcherCreationLock.unlock();
}

private DelayCloseIndexSearcher getOpenedSearcher()
     throws IOException
{
     searcherCreationLock.lock();
     DelayCloseIndexSearcher delaycloseindexsearcher;
     if(currentSearcher == null)
         currentSearcher = new DelayCloseIndexSearcher(directory);
     currentSearcher.open();
     delaycloseindexsearcher = currentSearcher;
     searcherCreationLock.unlock();
     return delaycloseindexsearcher;
}

private IndexReader constructIndexDeleter()
{
try{
     return IndexReader.open(directory);
}catch(IOException e){
     throw new LuceneException(e);
}
}

private void closeReader(IndexReader reader)
{
     try
     {
         if(reader != null)
         {
             if(log.isDebugEnabled())
                 log.debug(Thread.currentThread().getName() + "## closing reader");
             reader.close();
         }
     }
     catch(IOException e)
     {
         log.error("Error closing reader. " + e, e);
     }
}

private void closeSearcher(IndexSearcher searcher)
{
     try
     {
         if(searcher != null)
             searcher.close();
     }
     catch(IOException e)
     {
         log.error("Error occurred while closing searcher.", e);
     }
}

private void closeWriter(IndexWriter writer)
{
     try
     {
         if(writer != null)
         {
             if(log.isDebugEnabled())
                 log.debug("## closing writer");
             writer.close();
         } else
         {
             log.warn("## trying to close null writer.");
         }
     }
     catch(IOException e)
     {
         log.error("Error closing writer. " + e, e);
     }
}

private IndexWriter constructIndexWriter()
     throws LuceneException
{
     IndexWriter indexWriter;
     if(log.isDebugEnabled())
         log.debug(Thread.currentThread().getName() + "## opening writer");
     try{
     indexWriter = new IndexWriter(directory, analyzerForIndexing, false);
     if(batchMode.get())
     {
         indexWriter.setMaxBufferedDocs(configuration.getBatchMaxBufferedDocs());
         indexWriter.setMaxMergeDocs(configuration.getBatchMaxMergeDocs());
         indexWriter.setMergeFactor(configuration.getBatchMergeFactor());
     } else
     {
         indexWriter.setMaxBufferedDocs(configuration.getInteractiveMaxBufferedDocs());
         indexWriter.setMaxMergeDocs(configuration.getInteractiveMaxMergeDocs());
         indexWriter.setMergeFactor(configuration.getInteractiveMergeFactor());
     }
     indexWriter.setMaxFieldLength(configuration.getMaxFieldLength());
     return indexWriter;
     }catch(IOException e){
     throw new LuceneException(e);
     }
}

private void throwLuceneException(Throwable e)
{
     if(e instanceof Error)
         throw (Error)e;
     if(e instanceof RuntimeException)
         throw (RuntimeException)e;
     else
         throw new LuceneException(e);
}

private static Directory getDirectory(File path)
{
try{
     return FSDirectory.getDirectory(path, false);
}catch(IOException e){
     throw new LuceneException(e);
}
}

static
{
     log = Logger.getLogger(ConcurrentLuceneConnection.class);
}
}
网上找到的只有这个针对lucene分布式介绍，测试还是有问题，在写索引时还是会出现LOCK问题。

付涛 2007-12-28 16:23 发表评论

Lucene和Nutch的存储机制和机构分析

付涛 — Fri, 28 Dec 2007 07:55:00 GMT

主题：解决nutch的segmens的拆分与nutch crawl的重载(重新构建)问题
主要内容
一、Lucene的索引机制与索引文件结构
二、Nutch的爬虫分析与文件结构分析
三、Nutch segments的拆分索引实现方案
一、Lucene的索引机制与索引文件结构
1、Lucene的索引机制
2、Lucene文件格式
_0.f0，_0.f1 文档文件
_0.fnm域集合信息文件
0.frq; 0.prx位置与频率文件
*.fdt和*.fdx构成了域值/域索引文件
segment1.nrm标准化因子
- segments索引块文件
- deletable保存已删除文件的记录
-*.tii和*.tis构成了项字典
-lock(无扩展名) 用来控制读写的同步
二、Nutch的爬虫分析
Nutch segments分析
Nutch 的文件结构分析
三、Nutch segments的拆分解决方案

Lucene采取的是倒排索引结构存储结构建立反向索引。对爬取回来的信息通过Lucene Analyzer分词器提取出索引项以相关信息，如索引项的出现频率。然后分词器把这些信息写到索引文件中。其核心在于Lucene的索引文件结构（倒排索引结构），首先理解”反向索引”的概念。

反向索引是一种以索引项为中心来组织文档的方式，每个索引项指向一个文档序列，这个序列中的文档都包含该索引项。相反，在正向索引中，文档占据了中心的位置，每个文档指向了一个它所包含的索引项的序列。你可以利用反向索引轻松的找到那些文档包含了特定的索引项。 Lucene使用了反向索引作为其基本的索引结构。

Lucene索引index由若干段(segment)组成,每一段由若干的文档(document)组成,每一个文档由若干的域(field)组成,每一个域由若干的项(term)组成。项是最小的索引概念单位,它直接代表了一个字符串以及其在文件中的位置、出现次数等信息。域是一个关联的元组,由一个域名和一个域值组成,域名是一个字串,域值是一个项,比如将“标题”和实际标题的项组成的域。

文档是提取了某个文件中的所有信息之后的结果,这些组成了段,或者称为一个子索引。子索引可以组合为索引,也可以合并为一个新的包含了所有合并项内部元素的子索引。

Lucene采用倒排索引结构索引被处理为一个目录(文件夹),其中含有的所有文件即为其内容,这些文件按照所属的段不同分组存放,同组的文件拥有相同的文件名,不同的扩展名。此外还有三个文件,分别用来保存所有的段的记录、保存已删除文件的记录和控制读写的同步,它们分别是segments, deletable和lock文件,都没有扩展名。

每个段包含一组文件,它们的文件扩展名不同,但是文件名均为记录在文件segments中段的名字每个段的文件中。
主要记录了两大类的信息：域集合与项集合。由于索引信息是静态存储的,域集合与项集合中的文件组采用了一种类似的存储办法：一个小型的索引文件,运行时载入内存；一个对应于索引文件的实际信息文件,可以按照索引中指示的偏移量随机访问；索引文件与信息文件在记录的排列顺序上存在隐式的对应关系,即索引文件中按照“索引项

1、索引项2…”排列,则信息文件则也按照“信息项1、信息项2…”排列。域集合与项集合之间则通过域的在域记录文件(比如segment1.fnm)中所记录的域记录号维持对应关系,segment1.fdx与segment1.tii中就是通过这种方式保持联系。这样,域集合和项集合不仅仅联系起来,而且其中的文件之间也相互联系起来。这样,整个段的索引信息

就通过这些文档有机的组成。
Lucene所采用的索引文件格式。基本上而言,它是一个倒排索引。,但是Lucene在文件的安排上做了一些努力,比如使用索引/信息文件的方式,从文件安排的形式上提高查找的效率。

(_0.f0，_0.f1 文档文件)
文档号（Document Number）
      编号方式：Lucene用一个整形（interger）的文档号来指示文档。第一个被加入到索引的文档就是0号，顺序加入的文档将得到一个由前一个号码递增而来的号码。
     标准的技术是根据每一段号码多少为每一段分配一个段号。将段内文档号转换到段外时，加上段号。将某段外的文档号转换到段内时，根据每段中可能的转换后号码范围来判断文档属于那一段，并减调这一段的段号。例如有两个含5个文档的段合并，那么第一段的段号就是0，第二段段号5。第二段中的第三个文档，在段外的号码就是8。
(_0.fnm域集合信息)
    索引中的文档由一个或者多个域组成，这个文件包含了每个索引块中的域的信息。
  所有域名都存储在这个文件的域集合信息中文件中的域根据它们的次序编号。因此域0是文件中的第一个域，域1是接下来的，这个和文档号的编号方式相同。

项频数 .frq文件包含每一项的文档的列表，还有该项在对应文档中出现的频数。
项位置 .prx文件包含了某文档中某项出现的位置信息的列表。

(0.frq; 0.prx位置与频率文件)
项频数 .frq文件包含每一项的文档的列表，还有该项在对应文档中出现的频数。
项位置 .prx文件包含了某文档中某项出现的位置信息的列表。

(*.fdt和*.fdx构成了域值/域索引文件)
域值存储表（Stored Fields）域值存储表使用域索引 .fdx与域值 .fdt两个文件表示。

(segment1.nrm标准化因子)
.nrm文件包含了每个文档的标准化因子，其主要用在评分排序机制中。

(segments索引块文件)
Segments索引块又称segment段，这个文件包含了索引中的索引块信息，这个文件包含了每个索引块的名字以及大小等信息。

(deletable保存已删除文件的记录)
deletetable的文件包含了索引不再使用的文件的名字，这些文件可能并没有被实际的删除。
.del文件是可选的，只有在某段中存在删除操作后才存在。

(*.tii和*.tis构成了项字典 )
项字典用项信息（.tis文件）和项信息索引（.tii文件）两个文件表示。
项信息索引（.tii文件）
每个项信息索引文件包含.tis文件中的128个条目，依照条目在.tis文件中的顺序。这样设计是为了一次将索引信息读入内存能，然后使用它来随机的访问.tis文件。这个文件的结构和.tis文件非常类似，只在每个条目记录上增加了一个变量IndexDelta。

(lock(无扩展名) 用来控制读写的同步)
主要是用于防止进程在使用索引时，被其它文件操作修改索引。

Nutch的爬虫分析

1.         创建一个新的WebDb (admin db -create)；
2.         将抓取起始URLs写入WebDB中 (inject)；
3.         根据WebDB生成fetchlist并写入相应的segment(generate)；
4.         根据fetchlist中的URL抓取网页 (fetch).；
5.         根据抓取网页更新WebDb (updatedb).
通过3—5这个循环就可以实现Nutch的深度抓取。

Nutch segments分析
对于segments/segment/下的文件以后分析）结构，在nutch爬虫运行后在webdb文件夹下一共产生如下五个文件：
linksByMD5 linksByURL pagesByMD5 pagesByURL stats
其中：
Stats文件用来存放爬虫爬行后的版本信息，处理网页数量，连接数量；
pagesByURL等其余四个文件夹下均有两个文件――index和data，其中data文件用来存放有序的key／value对，排序是通过选择不同的key和comparator来改变的，当然里面会有一些其他信息，比如在pagesByURL中，就每隔一定长度的key／value对放入一个用来定位的信息（syn）；index文件用来存放索引，但是这个索引文件也是一个有序的，这个里面存放的是key和位置信息，但是在data文件中出现的key在这个index中都能找到的，它为了节省空间，实施了每隔一段key／value建立一条索引，这样在查找的时候，因为是有序的，所以采用２分查找，如果找不到，则返回最后时候的最小的位置信息，这个位置离我们要找的目标是相当近的，然后在data文件的这个位置向前找就可以很快找到了！
另外，nutch维持这个webdb的方式是，在填加，删除网页或者连接时，并不是直接向这个webdb中填加网页或者连接，而是在WebDBWriter 中的内部类PageInstructionWriter或者LinkInstructionWriter中填加一条对网页操作的命令，然后最后对存放的命令进行排序去重，最后将这个命令与现有的webdb中存放的网页数据进行合并；

Fetcher类是进行实际网页抓取时候运行的类，爬虫产生的文件或文件夹都是由这个类产生的， Nutch提供了选项―是否对抓回的网页进行parse（解析），如果这个选项设置为false，将没有parseddata和parsedtext这两个文件夹。
nutch爬虫产生的文件几乎都是key/value对，不同的只是key/value的种类和值不同，爬虫运行后在segments文件夹的子文件夹产生
如下几个文件夹： content fetcher fetchlist index parse_data parse_text

其中content文件夹存放的内容对应protocol包中的content类；fetcher文件夹存放的内容对应的是fetcher包中的FetcherOutput类；fetchlist对应pagedb包总的fetchlist类；parse_data和parse_text分别对应parse包中的ParseData和ParseText类；

(Nutch segments)
如上面Nutch segments分析所述，对Nutch的segments有了清楚的了解。
提示点：Lucene 中的segment和Nutch中的不同，Lucene中的segment是索引index的一部分，但是Nutch中的segment只是WebDB中各个部分网页的内容和索引，最后通过其生成的index跟这些segment已经毫无关系了。

(Nutch crawldb)
其主要是segments段的crawl_fetch与parse_data的数据。并利用其crawldb循环fetch 生成segments深度抓取。

(Nutch linkdb)
其存放的为segments所有段的crawl_fetch数据，其URL列表。

(Nutch indexes)
由Nutch crawldb,linkdb segments生成indexes索引集。其存放结构是结合Lucene的索引机制存放的。

(Nutch index)
由nutch indexes 单独提取索引信息。其索引结果可利用Luke进行索引结果查询。

Nutch 在tomcat下使用的资源主要是segments,linkdb,indexes。

nutch segments的拆分解决方案
从上面的分析可以得出Nutch的爬虫数据都以segments段存放信息。
我们只需要对segments进行slice拆分，就可以重新构造crawl数据源结构。
然后再利用nutch的相应操作完成对nutch segments的拆分与重构。

付涛 2007-12-28 15:55 发表评论

BlogJava-裤衩的天空-文章分类-Lucene研究

Lucene并发连接实现 问题

Lucene和Nutch的存储机制和机构分析

Lucene并发连接实现问题