Hive on Spark源码分析（六）—— RemoteSparkJobMonitor与JobHandle

Hive on Spark源码分析（一）—— SparkTask
Hive on Spark源码分析（二）—— SparkSession与HiveSparkClient
Hive on Spark源码分析（三）—— SparkClilent与SparkClientImpl（上）
Hive on Spark源码分析（四）—— SparkClilent与SparkClientImpl（下）
Hive on Spark源码分析（五）—— RemoteDriver
Hive on Spark源码分析（六）—— RemoteSparkJobMonitor与JobHandle 

RemoteSparkJobMonitor负责监控一个RSC远程任务的执行状态。它会循环获取任务的执行情况，直到任务完成/失败/kill掉，并将当前任务的状态打印到console。RemoteSparkJobMonitor中主要的方法就是startMonitor，它会根据任务执行的不同情况修改返回码，调用过程是:

SparkTask.execute => rc=jobRef.monitorJob() => RemoteSparkJobRef.monitorJob() => return remoteSparkJobMonitor.startMonitor()

该方法主要内容如下：

1. RemoteSparkJobMonitor循环获取Job执行状态：

 
 
JobHandle.State state = sparkJobStatus.getRemoteJobState();

  
  
public JobHandle.State getRemoteJobState() {
    return jobHandle.getState();
}

2. Job共有六种状态（state）：SENT，QUEUED，STARTED，SUCCEEDED，FAILED，CANCELED。根据不同状态做不同处理，其中SENT状态和QUEUED状态使用相同的处理逻辑：

  
  
        switch (state) {
        case SENT:
        case QUEUED:
          long timeCount = (System.currentTimeMillis() - startTime) / 1000;
          //monitorTimeoutInteval是配置文件中hive.spark.job.monitor.timeout的值
          if ((timeCount > monitorTimeoutInteval)) {
            console.printError("Job hasn\'t been submitted after " + timeCount + "s." +
                " Aborting it.\\nPossible reasons include network issues, " +
                "errors in remote driver or the cluster has no available resources, etc.\\n" +
                "Please check YARN or Spark driver\'s logs for further information.\\nReason1 from RemoteSparkJobMonitor");
            console.printError("Status: " + state);
            running = false;
            done = true;
            rc = 2;
          }
          break;

如果超过预设job提交时间，则修改return code = 2，提示timeCount时间后Job仍未提交，否则继续继续等待

如果state为STARTED，打印job信息和执行进度：

 
 
case STARTED:
          JobExecutionStatus sparkJobState = sparkJobStatus.getState();
          if (sparkJobState == JobExecutionStatus.RUNNING) {
            Map<String, SparkStageProgress> progressMap = sparkJobStatus.getSparkStageProgress();
            if (!running) {
              perfLogger.PerfLogEnd(CLASS_NAME, PerfLogger.SPARK_SUBMIT_TO_RUNNING);
              printAppInfo();
              // print job stages.
              console.printInfo("\nQuery Hive on Spark job["
                + sparkJobStatus.getJobId() + "] stages:");
              for (int stageId : sparkJobStatus.getStageIds()) {
                console.printInfo(Integer.toString(stageId));
              }
              console.printInfo("\nStatus: Running (Hive on Spark job["
                + sparkJobStatus.getJobId() + "])");
              running = true;
              console.printInfo("Job Progress Format\nCurrentTime StageId_StageAttemptId: "
                + "SucceededTasksCount(+RunningTasksCount-FailedTasksCount)/TotalTasksCount [StageCost]");
            }
            printStatus(progressMap, lastProgressMap);
            lastProgressMap = progressMap;
          }
          break;

负责打印任务信息的方法printStatus继承自父类SparkJobMonitor，它会计算总的task数、正在执行的任务数、已完成的任务数和失败的任务数，并进行格式化输出。

其余情况类似，如果状态为SUCCEEDED，打印成功或失败信息及状态码（不修改，默认为0，表示执行成功）；如果为FAILED，打印错误信息，修改return code = 3。

 
 
case SUCCEEDED:
          Map<String, SparkStageProgress> progressMap = sparkJobStatus.getSparkStageProgress();
          printStatus(progressMap, lastProgressMap);
          lastProgressMap = progressMap;
          double duration = (System.currentTimeMillis() - startTime) / 1000.0;
          console.printInfo("Status: Finished successfully in "
            + String.format("%.2f seconds", duration));
          running = false;
          done = true;
          break;
        case FAILED:
          console.printError("Status: Failed");
          running = false;
          done = true;
          rc = 3;
          break;
        }

如果任务还没有结束，则等待checkInterval时间，然后再次获取任务状态：

  
  
if (!done) {
    Thread.sleep(checkInterval);
}

如果捕获到异常，输出错误信息，修改return code = 1，任务标记为完成：

   
   
        catch (Exception e) {
        String msg = " with exception \'" + Utilities.getNameMessage(e) + "\'";
        msg = "Failed to monitor Job[ " + sparkJobStatus.getJobId() + "]" + msg;
        // Has to use full name to make sure it does not conflict with
        // org.apache.commons.lang.StringUtils
        LOG.error(msg, e);
        console.printError(msg, "\\n" + org.apache.hadoop.util.StringUtils.stringifyException(e));
        rc = 1;
        done = true;
      } finally {
        if (done) {
          break;
        }
      }
    }

以上这就是RemoteSparkJobMonitor的内容。下面看一下JobHandle。

JobHandle可以认为是一个job的句柄，用来监控和控制一个正在运行的远程任务。我们首先看一下JobHandle接口中定义的两个特殊的结构，首先state：

  
  
  static enum State {
    SENT,
    QUEUED,
    STARTED,
    CANCELLED,
    FAILED,
    SUCCEEDED;
  }

State是一个枚举类型值，表示job的当前状态，具体类型我们已经在上面提过。从SENT到SUCCEEDED，ordinal依次增加。

另外一个是一个监听器的接口Listener，用来监控job的state，其中的各种回调函数会在相应的事件发生时被调用：

   
   
  static interface Listener<T extends Serializable> {
    void onJobQueued(JobHandle<T> job);
    void onJobStarted(JobHandle<T> job);
    void onJobCancelled(JobHandle<T> job);
    void onJobFailed(JobHandle<T> job, Throwable cause);
    void onJobSucceeded(JobHandle<T> job, T result);
    /**
     * Called when a monitored Spark job is started on the remote context. This callback
     * does not indicate a state change in the client job's status.
     */
    void onSparkJobStarted(JobHandle<T> job, int sparkJobId);
  }

接口中其他的方法我们直接到JobHandleImpl 中去看具体的实现。 首先是构造方法，注意到state在构造方法中初始化为SENT状态：

 
 
JobHandleImpl(SparkClientImpl client, Promise<T> promise, String jobId) {
    this.client = client;
    this.jobId = jobId;
    this.promise = promise;
    this.listeners = Lists.newLinkedList();
    this.metrics = new MetricsCollection();
    this.sparkJobIds = new CopyOnWriteArrayList<Integer>();
    this.state = State.SENT;
    this.sparkCounters = null;
  }

下面这些方法都是通过JobHandleImpl内部的promise对象，以delegate的方式进行是实现。

   
   
  /** Requests a running job to be cancelled. */
  @Override
  public boolean cancel(boolean mayInterrupt) {
    if (changeState(State.CANCELLED)) {
      client.cancel(jobId);
      promise.cancel(mayInterrupt);
      return true;
    }
    return false;
  }
  @Override
  public T get() throws ExecutionException, InterruptedException {
    return promise.get();
  }
  @Override
  public T get(long timeout, TimeUnit unit)
      throws ExecutionException, InterruptedException, TimeoutException {
    return promise.get(timeout, unit);
  }
  @Override
  public boolean isCancelled() {
    return promise.isCancelled();
  }
  @Override
  public boolean isDone() {
    return promise.isDone();
  }

一些简单的get方法，可以获取job的信息，直接返回类中的私有成员：

    
    
  @Override
  public MetricsCollection getMetrics() {
    return metrics;
  }
  @Override
  public List<Integer> getSparkJobIds() {
    return sparkJobIds;
  }
  @Override
  public SparkCounters getSparkCounters() {
    return sparkCounters;
  }
  @Override
  public State getState() {
    return state;
  }

然后是一个比较重要的方法changeState，通过这个方法对state进行修改：

 
 
boolean changeState(State newState) {
    synchronized (listeners) {
      if (newState.ordinal() > state.ordinal() && state.ordinal() < State.CANCELLED.ordinal()) {
        state = newState;
        for (Listener l : listeners) {
          fireStateChange(newState, l);
        }
        return true;
      }
      return false;
    }
  }

修改时需要判断新的状态的基数是否大于当前状态的基数，并且小于CANCELLED的基数，只有这样才能对将当前的state修改为新state。例如，如果当前state为SENT，newState为QUEUED，则可以进行修改；如果当前state为QUEUED ，newState为SENT，则不能修改。state修改后，通过fireStateChange触发已注册的listener中相应事件（state）对应的回调函数。

看一下fireStateChange，除了SENT状态外，其他状态的变化都会触发相应的回调函数：

   
   
  private void fireStateChange(State s, Listener l) {
    switch (s) {
    case SENT:
      break;
    case QUEUED:
      l.onJobQueued(this);
      LOG.debug("liban: onJobQueued in fireStateChange.");
      break;
    case STARTED:
      l.onJobStarted(this);
      LOG.debug("liban: onJobStarted in fireStateChange.");
      break;
    case CANCELLED:
      l.onJobCancelled(this);
      break;
    case FAILED:
      l.onJobFailed(this, promise.cause());
      break;
    case SUCCEEDED:
      try {
        l.onJobSucceeded(this, promise.get());
      } catch (Exception e) {
        // Shouldn\'t really happen.
        throw new IllegalStateException(e);
      }
      break;
    default:
      throw new IllegalStateException();
    }
  }

但是其实上面的几个回调函数，我在HOS源码中并没有找到具体实现，猜测可能是留给开发人员自己实现的接口？如果有同学了解的可以分享一下。

以上就是RemoteSparkJobMonitor与JobHandle的基本内容。

简单总结：JobHandle定义了与Job状态相关的接口，可以监控和控制job的状态，SparkJobMonitor则在一定时间阈值内循环获取job的状态，根据job的不同状态做不同处理，修改相应的返回码，标识任务结果状态。