Hadoop源码解读-Job初始化过程

首先看看Hadoop ssh 脚本 
   
elif [ "$COMMAND" = "jar" ] ; then 
      CLASS=org.apache.hadoop.util.RunJar 

任务递交。 
WordCount 里面有一句话： 
   

Java代码  

1. System.exit(job.waitForCompletion(true) ? 0 : 1);  

  

1.job.waitForCompletion：一般情况下我们提交一个job都是通过job.waitForCompletion方法提交，该方法内部会调用job.submit()方法 

Java代码  

1. public boolean waitForCompletion(boolean verbose    
2.                                    ) throws IOException, InterruptedException,    
3.                                             ClassNotFoundException {    
4.     if (state == JobState.DEFINE) {    
5.       submit();    
6.     }    
7.     if (verbose) {    
8.       jobClient.monitorAndPrintJob(conf, info);    
9.     } else {    
10.       info.waitForCompletion();    
11.     }    
12.     return isSuccessful();    
13.   }    

2.job.submit()：在submit中会调用setUseNewAPI()，setUseNewAPI()这个方法主要是判断是使用新的api还是旧的api，之后会调用connect()方法，该方法主要是实例化jobClient，然后会调用jobClient.submitJobInternal(conf)这个方法进行job的提交 

Java代码  

1. public void submit() throws IOException, InterruptedException,     
2.                               ClassNotFoundException {    
3.     ensureState(JobState.DEFINE);    
4.     setUseNewAPI();    
5.         
6.     // Connect to the JobTracker and submit the job    
7.     connect();    
8.     info = jobClient.submitJobInternal(conf);    
9.     super.setJobID(info.getID());    
10.     state = JobState.RUNNING;    
11.    }    

3.jobClient.submitJobInternal()：这个方法会将job运行时所需的所有文件上传到jobTarcker文件系统（一般是hdfs）中，同时进行备份（备份数默认是10，通过mapred.submit.replication变量可以设置），这个方法需要深入进行解读。 
4.JobSubmissionFiles.getStagingDir：这个方法是在jobClient.submitJobInternal()最先调用的，这个方法主要是获取一个job提交的根目录，主要是通过Path stagingArea = client.getStagingAreaDir();方法获得，这个方法最终会调用jobTracker.getStagingAreaDirInternal()方法，代码如下： 

Java代码  

1. private String getStagingAreaDirInternal(String user) throws IOException {    
2.    final Path stagingRootDir =    
3.      new Path(conf.get("mapreduce.jobtracker.staging.root.dir",    
4.            "/tmp/hadoop/mapred/staging"));    
5.    final FileSystem fs = stagingRootDir.getFileSystem(conf);    
6.    return fs.makeQualified(new Path(stagingRootDir,    
7.                              user+"/.staging")).toString();    
8.  }    

在获取了stagingDir之后会执行JobID jobId = jobSubmitClient.getNewJobId();为job获取一个jobId，然后执行Path submitJobDir = new Path(jobStagingArea, jobId.toString());获得该job提交的路径，也就是在stagingDir目录下建一个以jobId为文件名的目录。有了submitJobDir之后就可以将job运行所需的全部文件上传到对应的目录下了，具体是调用jobClient.copyAndConfigureFiles(jobCopy, submitJobDir)这个方法。 

5.jobClient.copyAndConfigureFiles(jobCopy, submitJobDir)：这个方法最终调用jobClient.copyAndConfigureFiles(job, jobSubmitDir, replication);这个方法实现文件上传。 

6.jobClient.copyAndConfigureFiles(job, jobSubmitDir, replication)：这个方法首先获取用户在使用命令执行job的时候所指定的-libjars, -files, -archives文件，对应的conf配置参数是tmpfiles tmpjars tmparchives，这个过程是在ToolRunner.run()的时候进行解析的，当用户指定了这三个参数之后，会将这三个参数对应的文件都上传到hdfs上，下面我们具体看一个参数的处理：tmpfiles（其他两个基本相同） 

7.jobClient处理tmpfiles：该方法会将tmpfiles参数值按‘，’分割，然后将每一个文件上传到hdfs，其中如何文件的路径本身就在hdfs中，那么将不进行上传操作，上传操作只针对文件不在hdfs中的文件。调用的方法是： 
Path newPath = copyRemoteFiles(fs,filesDir, tmp, job, replication)， 
该方法内部使用的是FileUtil.copy(remoteFs, originalPath, jtFs, newPath, false, job)方法将文件上传至hdfs，注意此处的remoteFs和jtFs，remoteFs就是需上传文件的原始文件系统，jtFs则是jobTracker的文件系统（hdfs）。 
在文件上传至hdfs之后，会执行DistributedCache.createSymlink(job)这个方法，这个方法是创建一个别名(好像是这么个名字)，这里需要注意的是tmpfiles和tmparchives都会创建别名，而tmpjars则不会，个人认为tmpjars则jar文件，不是用户在job运行期间调用，所以不需要别名，而tmpfiles和tmparchives则在job运行期间用户可能会调用，所以使用别名可以方便用户调用 

8.将这三个参数指定的文件上传到hdfs之后，需要将job的jar文件上传到hdfs，名称为submitJobDir/job.jar，使用fs.copyFromLocalFile(originalJarFile, submitJarFile)上传即可。 
到这里jobClient.copyAndConfigureFiles(jobCopy, submitJobDir)方法就完成了，期间丢了jobClient.copyAndConfigureFiles(jobCopy, submitJobDir)，TrackerDistributedCacheManager.determineTimestampsAndCacheVisibilities(job)，TrackerDistributedCacheManager.getDelegationTokens(job,  job.getCredentials()) 
三个方法，这三个方法是进行一些cached archives and files的校验和保存其时间戳和权限内容 

9.继续我们的jobClient.submitJobInternal()方法，这之后会根据我们设置的outputFormat类执行output.checkOutputSpecs(context)，进行输出路径的检验，主要是保证输出路径不存在，存在会抛出异常。这之后就是对输入文件进行分片操作了，writeSplits(context, submitJobDir)。 
10.jobClient.writeSplits()：这个方法内部会根据我们之前判断的使用new-api还是old-api分别进行分片操作，我们只看new-api的分片操作。 

Java代码  

1.    
2. private int writeSplits(org.apache.hadoop.mapreduce.JobContext job,    
3.       Path jobSubmitDir) throws IOException,    
4.       InterruptedException, ClassNotFoundException {    
5.     JobConf jConf = (JobConf)job.getConfiguration();    
6.     int maps;    
7.     if (jConf.getUseNewMapper()) {    
8.       maps = writeNewSplits(job, jobSubmitDir);    
9.     } else {    
10.       maps = writeOldSplits(jConf, jobSubmitDir);    
11.     }    
12.     return maps;    
13.   }   
14.    

11.jobClient.writeNewSplits()：这个方法主要是根据我们设置的inputFormat.class通过反射获得inputFormat对象，然后调用inputFormat对象的getSplits方法，当获得分片信息之后调用JobSplitWriter.createSplitFiles方法将分片的信息写入到submitJobDir/job.split文件中。 

Java代码  

1. private <T extends InputSplit>    
2.  int writeNewSplits(JobContext job, Path jobSubmitDir) throws IOException,    
3.      InterruptedException, ClassNotFoundException {    
4.    Configuration conf = job.getConfiguration();    
5.    InputFormat<?, ?> input =    
6.      ReflectionUtils.newInstance(job.getInputFormatClass(), conf);    
7.     
8.    List<InputSplit> splits = input.getSplits(job);    
9.    T[] array = (T[]) splits.toArray(new InputSplit[splits.size()]);    
10.     
11.    // sort the splits into order based on size, so that the biggest    
12.    // go first    
13.    Arrays.sort(array, new SplitComparator());    
14.    JobSplitWriter.createSplitFiles(jobSubmitDir, conf,    
15.        jobSubmitDir.getFileSystem(conf), array);    
16.    return array.length;    
17.  }    

12.JobSplitWriter.createSplitFiles：这个方法的作用就是讲分片信息写入到submitJobDir/job.split文件中，方法内部调用 
JobSplitWriter.writeNewSplits进行写操作 

13.JobSplitWriter.writeNewSplits：该方法具体对每一个InputSplit对象进行序列化写入到输出流中，具体每个InputSplit对象写入的信息包括： 
split.getClass().getName()，serializer.serialize(split)将整个对象序列化。然后将InputSplit对象的locations信息放入SplitMetaInfo对象中，同时还包括InputSpilt元信息在job.split文件中的偏移量，该InputSplit的长度，再将SplitMetaInfo对象。 
然后调用JobSplitWriter.writeJobSplitMetaInfo()方法将SplitMetaInfo对象写入submitJobDir/job.splitmetainfo文件中。 

14.JobSplitWriter.writeJobSplitMetaInfo()： 
将SplitMetaInfo对象写入submitJobDir/job.splitmetainfo文件中， 
具体写入的信息包括：JobSplit.META_SPLIT_FILE_HEADER，splitVersion，allSplitMetaInfo.length（SplitMetaInfo对象的个数，一个split对应一个SplitMetaInfo），然后分别将所有的SplitMetaInfo对象序列化到输出流中， 
到此文件的分片工作完成。 

15.继续回头看jobClient.submitJobInternal()方法：在上一步进行分片操作之后，或返回切片的数目，据此设定map的数量，所以在job中设置的map数量是没有用的。 
16.继续往下走： 

Java代码  

1. String queue = jobCopy.getQueueName();    
2.           AccessControlList acl = jobSubmitClient.getQueueAdmins(queue);    
3.           jobCopy.set(QueueManager.toFullPropertyName(queue,    
4.               QueueACL.ADMINISTER_JOBS.getAclName()), acl.getACLString());   

这三句话是获得job对应的任务队列信息，这里涉及到hadoop的作业调度内容，就不深入研究了 

17.继续：下面就是讲job的配置文件信息(jobConf对象)写入到xml文件中，以便用户查看，具体文件是：submitJobDir/job.xml，通过jobCopy.writeXml(out)方法， 
方法比较简单，就是写xml文件。下面就进入到jobTracker提交任务环节了，status = jobSubmitClient.submitJob(jobId, submitJobDir.toString(), jobCopy.getCredentials())， 
就到这吧，后面下次再慢慢研究。 
总结下：在用户提交job之后，第一步主要是jobClient对job进行一些必要的文件上传操作 
，主要包括： 

1）为job生成一个jobId，然后获得job提交的stagingDir，根据jobId获得submitJobDir，之后所有的job运行时文件豆浆保存在此目录下 

2）将用户在命令行通过-libjars, -files, -archives指定的文件上传到jobTracker的文件系统中，并将job.jar上传到hdfs中 

3）校验输出路径 

4）进行输入文件的分片操作，并将分片信息写入submitJobDir下的相应文件中，有两个文件：job.split以及job.splitmetainfo 

5）将job的配置参数(jobConf对象)写入到job.xml文件中。 

18. jobTracker进行job的提交过程，还有一个JobSubmissionProtocol的实现是LocalJobRunner，这是本地执行的时候使用的，真正集群运行Job还是使用的jobTracker，所以只看jobTracker类的submitJob 
      18.1.jobTracker.submitJob()：第一句就是checkJobTrackerState()这个是检查jobTracker状态，是否运行中，这里说一句，jobTracker是在hadoop集群启动的时候启动的，也就是在执行start-all或者start-mapred的时候启动，启动的时候会调用JobTracker的main方法，然后在jps的时候就可以看见一个jobTracker的进程了。下面来看一下JobTracker.main()方法。 
       18.2.JobTracker.main()：第一句是JobTracker tracker = startTracker(new JobConf())，这是实例化一个jobTracke实例。 
       18.3.JobTracker.startTracker()：result = new JobTracker(conf, identifier)，实例化一个jobTracker对象，在实例化的时候会做很多事，所以还是进去瞅瞅。 
       18.4.JobTracker.JobTracker()：实例化的时候会初始化很多参数，记也记不住，主要看下实例化taskScheduler的内容： 

Java代码  

1. Class<? extends TaskScheduler> schedulerClass  
2.       = conf.getClass("mapred.jobtracker.taskScheduler",JobQueueTaskScheduler.class, TaskScheduler.class)；  taskScheduler = (TaskScheduler) ReflectionUtils.newInstance(schedulerClass, conf)，  

这两句就是根据配置文件设置的taskScheduler类名， 
通过反射获得对应的taskScheduler对象， 
在实例化的时候虽然不同的TaskScheduler具体操作不一样，但是统一的都会初始化一个JobListener对象， 
这个对象就是后面将要监听job的listener。剩下的内容就不说了。 
回到JobTracker.startTracker()方法。 
5.JobTracker.JobTracker()： 
在实例化jobTracker之后， 
会执行result.taskScheduler.setTaskTrackerManager(result) 
，这个就是将jobTracker对象设置给taskScheduler。后面就什么了，现在可以回到main方法了 

Java代码  

1. public static JobTracker startTracker(JobConf conf, String identifier, boolean initialize)     
2.   throws IOException, InterruptedException {    
3.     DefaultMetricsSystem.initialize("JobTracker");    
4.     JobTracker result = null;    
5.     while (true) {    
6.       try {    
7.         result = new JobTracker(conf, identifier);    
8.         result.taskScheduler.setTaskTrackerManager(result);    
9.         break;    
10.       } catch (VersionMismatch e) {    
11.         throw e;    
12.       } catch (BindException e) {    
13.         throw e;    
14.       } catch (UnknownHostException e) {    
15.         throw e;    
16.       } catch (AccessControlException ace) {    
17.         // in case of jobtracker not having right access    
18.         // bail out    
19.         throw ace;    
20.       } catch (IOException e) {    
21.         LOG.warn("Error starting tracker: " +     
22.                  StringUtils.stringifyException(e));    
23.       }    
24.       Thread.sleep(1000);    
25.     }    
26.     if (result != null) {    
27.       JobEndNotifier.startNotifier();    
28.       MBeans.register("JobTracker", "JobTrackerInfo", result);    
29.       if(initialize == true) {    
30.         result.setSafeModeInternal(SafeModeAction.SAFEMODE_ENTER);    
31.         result.initializeFilesystem();    
32.         result.setSafeModeInternal(SafeModeAction.SAFEMODE_LEAVE);    
33.         result.initialize();    
34.       }    
35.     }    
36.     return result;    
37.   }    

.JobTracker.main()：在实例化jobTracker之后，会调用tracker.offerService()方法， 
之后main方法就没什么了，下面看看tracker.offerService()这个方法 

Java代码  

1. public static void main(String argv[]    
2.                           ) throws IOException, InterruptedException {    
3.     StringUtils.startupShutdownMessage(JobTracker.class, argv, LOG);    
4.         
5.     try {    
6.       if(argv.length == 0) {    
7.         JobTracker tracker = startTracker(new JobConf());    
8.         tracker.offerService();    
9.       }    
10.       else {    
11.         if ("-dumpConfiguration".equals(argv[0]) && argv.length == 1) {    
12.           dumpConfiguration(new PrintWriter(System.out));    
13.         }    
14.         else {    
15.           System.out.println("usage: JobTracker [-dumpConfiguration]");    
16.           System.exit(-1);    
17.         }    
18.       }    
19.     } catch (Throwable e) {    
20.       LOG.fatal(StringUtils.stringifyException(e));    
21.       System.exit(-1);    
22.     }    
23.   }    

只看taskScheduler.start()这个方法，因为这里只是想分析下JobTracker提交job的过程. 
    18.5 taskScheduler.start()：这个方法就是启动TaskScheduler，这个方法不同taskScheduler也不同，但是统一的还是会有一个taskTrackerManager.addJobInProgressListener(jobListener)这个操作，taskTrackerManager就是jobTracker（第5步），这句的意思是为jobTracker添加jobListener，用来监听job的。这句的内部就是调用jobTracker的jobInProgressListeners集合的add(listener)方法。 
到这里可以说看完了整个JobTracker的启动过程，虽然很浅显，但是对于后面将要分析的内容，这些就够了。下面来看看job的提交过程，也就是jobTracker的submit()方法。 

       jobTracker的submit()  
一， 第一步是checkSafeMode()，检查是否在安全模式，在安全模式则抛出异常。 
然后执行 
jobInfo = new JobInfo(jobId, new Text(ugi.getShortUserName()),new Path(jobSubmitDir)，生成一个jobInfo对象，jobInfo主要保存job的id,user,jobSubmitDir（也就是job的任务目录，上一篇文章提到）。 
接着是判断job是否可被recovered（job失败的时候尝试再次执行）， 
如果允许的话(默认允许)，则将jobInfo对象序列化到job-info文件中。 
接着到达最关键的地方，job = new JobInProgress(this, this.conf, jobInfo, 0, ts)， 
为job实例化一个JobInProgress对象，这个对象将会对job以后的所有情况进行负责，如初始化，执行等。下面看看JobInProgress对象的初始化操作。 
  二， 这里看下将job.xml下载到本地的操作。然后就是job的队列信息， 
默认的队列名是default，Queue queue = this.jobtracker.getQueueManager().getQueue(queueName)，这个主要是根据hadoop所使用的taskScheduler有关，具体不研究。剩下的是一些参数的初始化，如map的数目，reduce的数目等。这里还有个设置job的优先级的，默认是normal。this.priority = conf.getJobPriority();this.status.setJobPriority(this.priority); 
还有检查taskLimit的操作，就是检查map+reduce的任务数是否超出mapred.jobtracker.maxtasks.per.job设置的值，默认是-1，就是没有限制的意思。回到jobTracker.submit()方法 

Java代码  

1. this.localJobFile = default_conf.getLocalPath(JobTracker.SUBDIR    
2.           +"/"+jobId + ".xml");    
3.       Path jobFilePath = JobSubmissionFiles.getJobConfPath(jobSubmitDir);    
4.       jobFile = jobFilePath.toString();    
5.       fs.copyToLocalFile(jobFilePath, localJobFile);    
6.       conf = new JobConf(localJobFile);    

   三， submit()：实例化JobInProgress之后，会根据jobProfile获取job的队列信息， 
并判断相应的队列是否在运行中，不在则任务失败。然后检查内存情况checkMemoryRequirements(job)，再调用taskScheduler的taskScheduler.checkJobSubmission(job) 
检查任务提交情况（具体是啥玩意，不太情况）。 
接下来就是执行 
status = addJob(jobId, job)， 
为Job设置listener。 
addJob()：前面说过，在初始化jobTracker的时候会实例化taskScheduler， 
然后调用taskScheduler的start()方法，为jobTracker添加JobListener对象， 
所以这里的JobInProgressListener对象就是相应的taskScheduler的JobListener， 
这里为job添加了JobListener。 

Java代码  

1. private synchronized JobStatus addJob(JobID jobId, JobInProgress job)     
2.   throws IOException {    
3.     totalSubmissions++;    
4.     
5.     synchronized (jobs) {    
6.       synchronized (taskScheduler) {    
7.         jobs.put(job.getProfile().getJobID(), job);    
8.         for (JobInProgressListener listener : jobInProgressListeners) {    
9.           listener.jobAdded(job);    
10.         }    
11.       }    
12.     }    
13.     myInstrumentation.submitJob(job.getJobConf(), jobId);    
14.     job.getQueueMetrics().submitJob(job.getJobConf(), jobId);    
15.     
16.     LOG.info("Job " + jobId + " added successfully for user '"     
17.              + job.getJobConf().getUser() + "' to queue '"     
18.              + job.getJobConf().getQueueName() + "'");    
19.     AuditLogger.logSuccess(job.getUser(),     
20.         Operation.SUBMIT_JOB.name(), jobId.toString());    
21.     return job.getStatus();    
22.   }    

==================== JobTracker init job================= 
JobTracker.initJob()：主要调用job.initTasks()，下面进入到JobInProgress.initTasks()。 

JobInProgress.initTasks()：为job对象设置优先级setPriority(this.priority)， 
接着读取分片信息文件获取分片信息，SplitMetaInfoReader.readSplitMetaInfo()这个方就是jobInPorgress用来读取分分片信息的，读取过程与写入过程相对应， 
具体还是较简单的。读取了分片信息之后，根据分片数量创建相应数量的mapTask（TaskInProgress对象），接下来会执行nonRunningMapCache = createCache(splits, maxLevel)，这个方法是根据每个分片的location信息，
然后根据location的host判断每个host上所有的job，并放入cache中。 
接着根据设置的reduce数量新建对应的reduceTask（TaskInProgress对象）， 
并加入到nonRunningReduces队列中， 
并根据mapred.reduce.slowstart.completed.maps（百分比，默认是5%）参数的值计算completedMapsForReduceSlowstart（ 
分别对应map和reduce task。到此initTask完成， 
initTask完成JobTracker的initJob也就差不多完成了, 

Java代码  

1.   public synchronized void initTasks()   
2.   throws IOException, KillInterruptedException, UnknownHostException {  
3.      // log the job priority  
4.     setPriority(this.priority);  
5.    //........  
6.   
7.    numMapTasks = splits.length;  
8. // 添加Map 和 reduce   
9.  jobtracker.getInstrumentation().addWaitingMaps(getJobID(), numMapTasks);  
10.     jobtracker.getInstrumentation().addWaitingReduces(getJobID(), numReduceTasks);  
11.   //....  
12. //create map;  
13.    maps = new TaskInProgress[numMapTasks];  
14. //....  
15. //create reduce  
16. this.reduces = new TaskInProgress[numReduceTasks];  
17. //下面是cleanup 和log  
18. //....  
19.   
20.   
21. }