YARN 的服务库和事件库及其使用

YARN采用了基于事件驱动的并发模型，该模型能够大大增强并发性，从而提高系统整体性能。为了构件模型，YARN将各种处理逻辑抽象成事件和对应事件调度器，并将每类事件的处理过程分割成多个步骤，用有限状态机表示。YARN中的事件处理模型可概括为下图所示。

整个处理过程大致为：处理请求会作为事件进入系统，由中央异步调度器（AsyncDispatcher）负责传递给相应事件调度器（Event Handler）。该事件调度器可能将该事件转发给另外一个事件调度器，也可能交给一个带有有限状态机的事件处理器，其处理结果也以事件的形式输出给中央异步调度器。而新的事件会再次被中央异步调度器转发给下一个事件调度器，直至处理完成（达到终止条件）。

YARN服务库和事件库的使用方法
为了说明YARN服务库和事件库的使用方法，举例如下。
1）定义Task事件

package com.event;

import org.apache.hadoop.yarn.event.AbstractEvent;

public class TaskEvent extends AbstractEvent<TaskEventType> {

    private String taskID ; //Task ID
    public TaskEvent(String taskID , TaskEventType type){
        super(type) ;
        this.taskID = taskID ;
    }
    public String getTaskID(){
        return taskID ;
    }
}

其中，Task事件类型定义如下：

package com.event;

public enum TaskEventType {
    T_KILL ,
    T_SCHEDULE
}

2）定义Job事件

package com.event;

import org.apache.hadoop.yarn.event.AbstractEvent;

public class JobEvent extends AbstractEvent<JobEventType> {
    private String jobID ;
    public JobEvent(String jobID , JobEventType type){
        super(type) ;
        this.jobID = jobID ;
    }
    public String getJobID(){
        return this.jobID ;
    }

}

其中，Job事件类型定义如下：

package com.event;

public enum JobEventType {
    JOB_KILL ,
    JOB_INIT ,
    JOB_START
}

3）事件调度器。
接下来定义一个中央异步调度器，它接收Job和Task两种类型事件，并交给对应的事件处理器处理。

package com.event;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.service.CompositeService;
import org.apache.hadoop.service.Service;
import org.apache.hadoop.yarn.event.AsyncDispatcher;
import org.apache.hadoop.yarn.event.Dispatcher;
import org.apache.hadoop.yarn.event.EventHandler;

@SuppressWarnings("unchecked")
public class SimpleMRAppMaster extends CompositeService {
    private Dispatcher dispatcher ; // 中央异步调度器
    private String jobID ;
    private int taskNumber ; //该作业包含的任务数目
    private String[] taskIDs; //该作业内部包含的所有任务

    public SimpleMRAppMaster(String name , String jobID , int taskNumber){
        super(name) ;
        this.jobID = jobID ;
        this.taskNumber = taskNumber ;
        taskIDs = new String[taskNumber] ;
        for(int i=0 ; i<taskNumber ; i++){
            taskIDs[i] = new String(jobID + "_task_" + i) ;
        }
    }

    public void serviceInit(final Configuration conf) throws Exception{
        dispatcher = new AsyncDispatcher() ; //定义一个中央异步调度器
        //分别注册Job和Task事件调度器
        dispatcher.register(JobEventType.class, new JobEventDispatcher()) ;
        dispatcher.register(TaskEventType.class, new TaskEventDispatcher()) ;

        addService((Service)dispatcher) ;
        super.serviceInit(conf) ;
    }

    public Dispatcher getDispatcher(){
        return dispatcher ;
    }

    private class JobEventDispatcher implements EventHandler<JobEvent>{

        @Override
        public void handle(JobEvent event) {
            if(event.getType() == JobEventType.JOB_KILL){
                System.out.println("Receive JOB_KILL event, killing all the tasks");
                for(int i=0;i<taskNumber;i++){
                    dispatcher.getEventHandler().handle(new TaskEvent(taskIDs[i],TaskEventType.T_KILL)) ;
                }
            }else if(event.getType() == JobEventType.JOB_INIT){
                System.out.println("Receive JOB_INIT event, scheduling tasks") ;
                for(int i=0;i<taskNumber;i++){
                    dispatcher.getEventHandler().handle(new TaskEvent(taskIDs[i],TaskEventType.T_SCHEDULE)) ;
                }
            }

        }
    }

    private class TaskEventDispatcher implements EventHandler<TaskEvent>{

        @Override
        public void handle(TaskEvent event) {
            if(event.getType() == TaskEventType.T_KILL){
                System.out.println("Receive T_KILL event of task " + event.getTaskID());
            }else if(event.getType() == TaskEventType.T_SCHEDULE){
                System.out.println("Receive T_SCHEDULE event of task " + event.getTaskID());
            }

        }

    }

}

4）测试程序

package com.event;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.yarn.conf.YarnConfiguration;

public class SimpleMRAppMasterTest {
    public static void main(String args[]) throws Exception{
        String jobID = "job_20131215_12" ;
        SimpleMRAppMaster appMaster = new SimpleMRAppMaster("Simple MRAppMaster" , jobID , 5) ;
        YarnConfiguration conf = new YarnConfiguration(new Configuration()) ;
        appMaster.serviceInit(conf) ;
        appMaster.init(conf) ;
        appMaster.start() ;
        appMaster.getDispatcher().getEventHandler().handle(new JobEvent(jobID,JobEventType.JOB_KILL)) ;
        appMaster.getDispatcher().getEventHandler().handle(new JobEvent(jobID,JobEventType.JOB_INIT)) ;
    }
}

结果如图所示：

解释一下程序：
主函数

appMaster.getDispatcher().getEventHandler().handle(new JobEvent(jobID,JobEventType.JOB_KILL)) ;
        appMaster.getDispatcher().getEventHandler().handle(new JobEvent(jobID,JobEventType.JOB_INIT)) ;

表示往中央异步处理器放入了两个JobEventType类型的事件JobEventType.JOB_KILL和JobEventType.JOB_INIT。
中央异步处理器根据注册情况即可知晓什么类型的事件发往什么类型的调度器

//分别注册Job和Task事件调度器
dispatcher.register(JobEventType.class, new JobEventDispatcher()) ;//JobEventType类型的事件发往JobEventDispatcher调度器
dispatcher.register(TaskEventType.class, new TaskEventDispatcher()) ;//TaskEventType类型的事件发往TaskEventDispatcher调度器

JobEventType.JOB_KILL和JobEventType.JOB_INIT都是JobEventType类型的事件，调用JobEventDispatcher的handler方法，该方法根据事件类型，往中央异步调度器添加类型为TaskEventType类型的事件TaskEventType.T_KILL和TaskEventType.T_SCHEDULE。

中央异步处理器将事件TaskEventType.T_KILL和TaskEventType.T_SCHEDULE发往 TaskEventDispatcher，调用该调度器的handler方法进行处理。
流程如下图所示：