Nutch中Hadoop的应用之Injector

这学期“体系结构”的大做业是让写一个搜索引擎。因此前一段时间就简单看了下Nutch。这篇文章不会涉及到搜索引擎的细节，而是侧重于Hadoop在Nutch中的应用。

Hadoop在Nutch中是充当了数据的存储和MapReduce任务执行的角色。

咱们首先关注下页面爬取的过程。在Nutch中有个叫作“CrawlDb“的数据库，它是用来存储全部网络爬虫已知的URL地址，以及该地址的相应状态信息的的。其中状态信息包括爬取状态，上次爬取的时间，爬取间隔等。在Nutch中，该数据库使用Hadoop的Map文件形式存储。具体格式为<Text, CrawlDatum>。其中的key表示该URL的地址，而value则是Nutch本身定义的一个类型“CrawlDatum”，该类型实现了"Writable"接口，用来表示页面的一些属性。

“CrawlDatum"的类的具体形式以下：

package org.apache.nutch.crawl;

public class CrawlDatum implements WritableComparable<CrawlDatum>, Cloneable {
    private byte status;
    private long fetchTime = System.currentTimeMillis();
    private byte retries;
    private int fetchInterval;
    private float score = 1.0f;
    private byte[] signature = null;
    private long modifiedTime;
    private org.apache.hadoop.io.MapWritable metaData;
}

其中包括了页面的状态，抓取时间，抓取间隔等属性。

搜索引擎最初开始工做时，“CrawlDb”的内容是从一个简单的文本文件中获取的。该文本文件包含了一系列初始的URL地址。这个过程叫作“Injector”。若是"CrawlDb"已经存在，这时再调用“Injector"会把"CrawlDb"中原始的数据和提供的文本文件中的URL数据合并。

在Nutch中”Injector“实现分为4步，其中前两步为两个MapReduce任务。

第一个M/R任务是用来把文本文件中的URL进行过滤，规范化，包装成“CrawlDatum”，并最终存成临时的Sequence类型文件。该临时文件的格式为<Key, CrawlDatum>。

第二个M/R任务是用来把排序后的结果和原“CrawlDb"中的数据(若是存在)进行合并，生成新的CrawlDb文件。

第三步，用新生成的CrawlDb来替换原有的文件。

第四步，删除以前产生的临时文件。

下面咱们来看一下它的实现过程的代码。

public void inject(Path crawlDb, Path urlDir) throws IOException {

// 首先生成一个临时路径，来存放中间结果。
        Path tempDir =
                new Path(getConf().get("mapred.temp.dir", ".")
                + "/inject-temp-"
                + Integer.toString(new Random().nextInt(Integer.MAX_VALUE)));

// 建立排序任务
        JobConf sortJob = new NutchJob(getConf());
        // 设置相关属性
        FileInputFormat.addInputPath(sortJob, urlDir);
        sortJob.setMapperClass(InjectMapper.class);
        FileOutputFormat.setOutputPath(sortJob, tempDir);
        sortJob.setOutputFormat(SequenceFileOutputFormat.class);
        sortJob.setOutputKeyClass(Text.class);
        sortJob.setOutputValueClass(CrawlDatum.class);
        // 运行任务
        JobClient.runJob(sortJob);

// 建立合并任务
        JobConf mergeJob = CrawlDb.createJob(getConf(), crawlDb);
        // 设置属性
        FileInputFormat.addInputPath(mergeJob, tempDir);
        mergeJob.setReducerClass(InjectReducer.class);
        // 运行任务
        JobClient.runJob(mergeJob);

// 替换
        CrawlDb.install(mergeJob, crawlDb);

// 删除临时文件
        FileSystem fs = FileSystem.get(getConf());
        fs.delete(tempDir, true);
    }

 其中第一个任务的Mapper类为“InjectMapper”。咱们来看一下它的具体实现。

public void map(WritableComparable key, Text value,
                OutputCollector<Text, CrawlDatum> output, Reporter reporter)
                throws IOException {

// 得到一行URL地址 
            String url = value.toString();   

try {
                // 规范化和过滤URL
                url = urlNormalizers.normalize(url, URLNormalizers.SCOPE_INJECT);
                url = filters.filter(url);
            } catch (Exception e) {
                url = null;
            }

// 保存结果
            if (url != null) {                         
                value.set(url);
                CrawlDatum datum = new CrawlDatum(CrawlDatum.STATUS_INJECTED, customInterval);
                datum.setFetchTime(curTime);
                output.collect(value, datum);
            }
    }

该M/R任务执行后，以前的文本文件会被转化成一个临时的Sequence文件，其格式为<Text, CrawlDatum>。

接下来就是合并任务的执行。该合并任务是经过调用“CrawlDb.createJob()”方法来建立的，因此咱们首先来看一下该方法。

public static JobConf createJob(Configuration config, Path crawlDb)
            throws IOException {

// 为即将生成的新"CrawlDb"产生一个临时的随机路径
        Path newCrawlDb =
                new Path(crawlDb,
                Integer.toString(new Random().nextInt(Integer.MAX_VALUE)));

// 建立任务
        JobConf job = new NutchJob(config);
        // 得到已有的“CrawlDb"的路径
        Path current = new Path(crawlDb, CURRENT_NAME);
        // 若是该文件存在，则把它加入该任务的输入路径中
        if (FileSystem.get(job).exists(current)) {
            FileInputFormat.addInputPath(job, current);
        }

// 设置任务参数
        job.setInputFormat(SequenceFileInputFormat.class);
        job.setMapperClass(CrawlDbFilter.class);
        FileOutputFormat.setOutputPath(job, newCrawlDb);
        job.setOutputFormat(MapFileOutputFormat.class);
        job.setOutputKeyClass(Text.class);
        job.setOutputValueClass(CrawlDatum.class);

// 返回任务
        return job;
    }

能够看出，该合并任务的输出是个Map类型的文件，和以前的“CrawlDb"(若是存在)类型是相同的。该任务的Mapper类为“CrawlDbFilter”。其实现和以前的“InjectMapper”类似，这里略去不提。该任务的Reducer类为“InjectReducer”，它是合并的具体实施者。咱们来看一下它的实现。

public void reduce(Text key, Iterator<CrawlDatum> values,
                OutputCollector<Text, CrawlDatum> output, Reporter reporter)
                throws IOException {

boolean oldSet = false;
            while (values.hasNext()) {
                CrawlDatum val = values.next();
                if (val.getStatus() == CrawlDatum.STATUS_INJECTED) {
                    // 新URL
                    injected.set(val);
                    injected.setStatus(CrawlDatum.STATUS_DB_UNFETCHED);
                } else {
                    // 原“CrawlDb"中已有的URL
                    old.set(val);
                    oldSet = true;
                }
            }

CrawlDatum res = null;
            if (oldSet) {
                // 不覆盖已有的URL
                res = old;
            } else {
                res = injected;
            }

// 保存结果
            output.collect(key, res);
    }

这两个M/R任务执行后，系统中存在一新一旧两个"CrawlDb"文件(若是以前已经存在"CrawlDb")。接下来咱们须要把两个文件互换。相应的函数为CrawlDb.install(mergeJob, crawlDb)。咱们来看一下它的实现：

public static void install(JobConf job, Path crawlDb) throws IOException {

// 得到新"CrawlDb"路径
        Path newCrawlDb = FileOutputFormat.getOutputPath(job);
        FileSystem fs = new JobClient(job).getFs();
        Path old = new Path(crawlDb, "old");
        // 得到当前(旧)“CrawlDb"路径
        Path current = new Path(crawlDb, CURRENT_NAME);

// 若是当前已经存在“CrawlDb"，则把其重命名为”old"。
        if (fs.exists(current)) {
            fs.rename(current, old);
        }

// 把新的"CrawlDb"重命名为当前“CrawDb"
        fs.rename(newCrawlDb, current);

// 删除"old"
        if (fs.exists(old)) {
            fs.delete(old, true);
        }
    }

在替换以后，还剩下最后一步，即把以前的临时文件删除。至此，“Injection”的使命就完成了。