public void processEventForJobSummary(HistoryEvent event, JobSummary summary, JobId jobId) {
   // context.getJob could be used for some of this info as well.
   switch (event.getEventType()) {
     case JOB_SUBMITTED:
       JobSubmittedEvent jse = (JobSubmittedEvent) event;
       summary.setUser(jse.getUserName());
       summary.setQueue(jse.getJobQueueName());
       summary.setJobSubmitTime(jse.getSubmitTime());
       summary.setJobName(jse.getJobName());
       break;
     case NORMALIZED_RESOURCE:
       NormalizedResourceEvent normalizedResourceEvent = (NormalizedResourceEvent) event;
       if (normalizedResourceEvent.getTaskType() == TaskType.MAP) {
         summary.setResourcesPerMap(normalizedResourceEvent.getMemory());
       } else if (normalizedResourceEvent.getTaskType() == TaskType.REDUCE) {
         summary.setResourcesPerReduce(normalizedResourceEvent.getMemory());
       }
       break;
     case JOB_INITED:
       JobInitedEvent jie = (JobInitedEvent) event;
       summary.setJobLaunchTime(jie.getLaunchTime());
       break;
     case MAP_ATTEMPT_STARTED:
       TaskAttemptStartedEvent mtase = (TaskAttemptStartedEvent) event;
       if (summary.getFirstMapTaskLaunchTime() == 0)
         summary.setFirstMapTaskLaunchTime(mtase.getStartTime());
       break;
     case REDUCE_ATTEMPT_STARTED:
       TaskAttemptStartedEvent rtase = (TaskAttemptStartedEvent) event;
       if (summary.getFirstReduceTaskLaunchTime() == 0)
         summary.setFirstReduceTaskLaunchTime(rtase.getStartTime());
       break;
     case JOB_FINISHED:
       JobFinishedEvent jfe = (JobFinishedEvent) event;
       summary.setJobFinishTime(jfe.getFinishTime());
       summary.setNumFinishedMaps(jfe.getFinishedMaps());
       summary.setNumFailedMaps(jfe.getFailedMaps());
       summary.setNumFinishedReduces(jfe.getFinishedReduces());
       summary.setNumFailedReduces(jfe.getFailedReduces());
       if (summary.getJobStatus() == null)
         summary.setJobStatus(org.apache.hadoop.mapreduce.JobStatus.State.SUCCEEDED.toString());
       // TODO JOB_FINISHED does not have state. Effectively job history does not
       // have state about the finished job.
       setSummarySlotSeconds(summary, jfe.getTotalCounters());
       break;
     case JOB_FAILED:
     case JOB_KILLED:
       JobUnsuccessfulCompletionEvent juce = (JobUnsuccessfulCompletionEvent) event;
       summary.setJobStatus(juce.getStatus());
       summary.setNumFinishedMaps(context.getJob(jobId).getTotalMaps());
       summary.setNumFinishedReduces(context.getJob(jobId).getTotalReduces());
       summary.setJobFinishTime(juce.getFinishTime());
       setSummarySlotSeconds(summary, context.getJob(jobId).getAllCounters());
       break;
   }
 }
Exemple #2
0
/**
 * ************************************************ Describes the current status of a job. This is
 * not intended to be a comprehensive piece of data. For that, look at JobProfile.
 * ************************************************
 *
 * @deprecated Use {@link org.apache.hadoop.mapreduce.JobStatus} instead
 */
@Deprecated
@InterfaceAudience.Public
@InterfaceStability.Stable
public class JobStatus extends org.apache.hadoop.mapreduce.JobStatus {

  public static final int RUNNING = org.apache.hadoop.mapreduce.JobStatus.State.RUNNING.getValue();
  public static final int SUCCEEDED =
      org.apache.hadoop.mapreduce.JobStatus.State.SUCCEEDED.getValue();
  public static final int FAILED = org.apache.hadoop.mapreduce.JobStatus.State.FAILED.getValue();
  public static final int PREP = org.apache.hadoop.mapreduce.JobStatus.State.PREP.getValue();
  public static final int KILLED = org.apache.hadoop.mapreduce.JobStatus.State.KILLED.getValue();

  private static final String UNKNOWN = "UNKNOWN";

  private static final String[] runStates = {
    UNKNOWN, "RUNNING", "SUCCEEDED", "FAILED", "PREP", "KILLED"
  };

  /**
   * Helper method to get human-readable state of the job.
   *
   * @param state job state
   * @return human-readable state of the job
   */
  public static String getJobRunState(int state) {
    if (state < 1 || state >= runStates.length) {
      return UNKNOWN;
    }
    return runStates[state];
  }

  static org.apache.hadoop.mapreduce.JobStatus.State getEnum(int state) {
    switch (state) {
      case 1:
        return org.apache.hadoop.mapreduce.JobStatus.State.RUNNING;
      case 2:
        return org.apache.hadoop.mapreduce.JobStatus.State.SUCCEEDED;
      case 3:
        return org.apache.hadoop.mapreduce.JobStatus.State.FAILED;
      case 4:
        return org.apache.hadoop.mapreduce.JobStatus.State.PREP;
      case 5:
        return org.apache.hadoop.mapreduce.JobStatus.State.KILLED;
    }
    return null;
  }

  /** */
  public JobStatus() {}

  /**
   * Create a job status object for a given jobid.
   *
   * @param jobid The jobid of the job
   * @param mapProgress The progress made on the maps
   * @param reduceProgress The progress made on the reduces
   * @param cleanupProgress The progress made on cleanup
   * @param runState The current state of the job
   * @param user userid of the person who submitted the job.
   * @param jobName user-specified job name.
   * @param jobFile job configuration file.
   * @param trackingUrl link to the web-ui for details of the job.
   */
  public JobStatus(
      JobID jobid,
      float mapProgress,
      float reduceProgress,
      float cleanupProgress,
      int runState,
      String user,
      String jobName,
      String jobFile,
      String trackingUrl) {
    this(
        jobid,
        mapProgress,
        reduceProgress,
        cleanupProgress,
        runState,
        JobPriority.NORMAL,
        user,
        jobName,
        jobFile,
        trackingUrl);
  }

  /**
   * Create a job status object for a given jobid.
   *
   * @param jobid The jobid of the job
   * @param mapProgress The progress made on the maps
   * @param reduceProgress The progress made on the reduces
   * @param runState The current state of the job
   * @param user userid of the person who submitted the job.
   * @param jobName user-specified job name.
   * @param jobFile job configuration file.
   * @param trackingUrl link to the web-ui for details of the job.
   */
  public JobStatus(
      JobID jobid,
      float mapProgress,
      float reduceProgress,
      int runState,
      String user,
      String jobName,
      String jobFile,
      String trackingUrl) {
    this(jobid, mapProgress, reduceProgress, 0.0f, runState, user, jobName, jobFile, trackingUrl);
  }

  /**
   * Create a job status object for a given jobid.
   *
   * @param jobid The jobid of the job
   * @param mapProgress The progress made on the maps
   * @param reduceProgress The progress made on the reduces
   * @param runState The current state of the job
   * @param jp Priority of the job.
   * @param user userid of the person who submitted the job.
   * @param jobName user-specified job name.
   * @param jobFile job configuration file.
   * @param trackingUrl link to the web-ui for details of the job.
   */
  public JobStatus(
      JobID jobid,
      float mapProgress,
      float reduceProgress,
      float cleanupProgress,
      int runState,
      JobPriority jp,
      String user,
      String jobName,
      String jobFile,
      String trackingUrl) {
    this(
        jobid,
        0.0f,
        mapProgress,
        reduceProgress,
        cleanupProgress,
        runState,
        jp,
        user,
        jobName,
        jobFile,
        trackingUrl);
  }

  /**
   * Create a job status object for a given jobid.
   *
   * @param jobid The jobid of the job
   * @param setupProgress The progress made on the setup
   * @param mapProgress The progress made on the maps
   * @param reduceProgress The progress made on the reduces
   * @param cleanupProgress The progress made on the cleanup
   * @param runState The current state of the job
   * @param jp Priority of the job.
   * @param user userid of the person who submitted the job.
   * @param jobName user-specified job name.
   * @param jobFile job configuration file.
   * @param trackingUrl link to the web-ui for details of the job.
   */
  public JobStatus(
      JobID jobid,
      float setupProgress,
      float mapProgress,
      float reduceProgress,
      float cleanupProgress,
      int runState,
      JobPriority jp,
      String user,
      String jobName,
      String jobFile,
      String trackingUrl) {
    super(
        jobid,
        setupProgress,
        mapProgress,
        reduceProgress,
        cleanupProgress,
        getEnum(runState),
        org.apache.hadoop.mapreduce.JobPriority.valueOf(jp.name()),
        user,
        jobName,
        jobFile,
        trackingUrl);
  }

  public static JobStatus downgrade(org.apache.hadoop.mapreduce.JobStatus stat) {
    JobStatus old =
        new JobStatus(
            JobID.downgrade(stat.getJobID()),
            stat.getSetupProgress(),
            stat.getMapProgress(),
            stat.getReduceProgress(),
            stat.getCleanupProgress(),
            stat.getState().getValue(),
            JobPriority.valueOf(stat.getPriority().name()),
            stat.getUsername(),
            stat.getJobName(),
            stat.getJobFile(),
            stat.getTrackingUrl());
    old.setStartTime(stat.getStartTime());
    old.setFinishTime(stat.getFinishTime());
    old.setSchedulingInfo(stat.getSchedulingInfo());
    old.setHistoryFile(stat.getHistoryFile());
    return old;
  }
  /** @deprecated use getJobID instead */
  @Deprecated
  public String getJobId() {
    return getJobID().toString();
  }

  /** @return The jobid of the Job */
  public JobID getJobID() {
    return JobID.downgrade(super.getJobID());
  }

  /**
   * Return the priority of the job
   *
   * @return job priority
   */
  public synchronized JobPriority getJobPriority() {
    return JobPriority.valueOf(super.getPriority().name());
  }

  /**
   * Sets the map progress of this job
   *
   * @param p The value of map progress to set to
   */
  protected synchronized void setMapProgress(float p) {
    super.setMapProgress(p);
  }

  /**
   * Sets the cleanup progress of this job
   *
   * @param p The value of cleanup progress to set to
   */
  protected synchronized void setCleanupProgress(float p) {
    super.setCleanupProgress(p);
  }

  /**
   * Sets the setup progress of this job
   *
   * @param p The value of setup progress to set to
   */
  protected synchronized void setSetupProgress(float p) {
    super.setSetupProgress(p);
  }

  /**
   * Sets the reduce progress of this Job
   *
   * @param p The value of reduce progress to set to
   */
  protected synchronized void setReduceProgress(float p) {
    super.setReduceProgress(p);
  }

  /**
   * Set the finish time of the job
   *
   * @param finishTime The finishTime of the job
   */
  protected synchronized void setFinishTime(long finishTime) {
    super.setFinishTime(finishTime);
  }

  /** Set the job history file url for a completed job */
  protected synchronized void setHistoryFile(String historyFile) {
    super.setHistoryFile(historyFile);
  }

  /** Set the link to the web-ui for details of the job. */
  protected synchronized void setTrackingUrl(String trackingUrl) {
    super.setTrackingUrl(trackingUrl);
  }

  /** Set the job retire flag to true. */
  protected synchronized void setRetired() {
    super.setRetired();
  }

  /** Change the current run state of the job. */
  protected synchronized void setRunState(int state) {
    super.setState(getEnum(state));
  }

  /** @return running state of the job */
  public synchronized int getRunState() {
    return super.getState().getValue();
  }

  /**
   * Set the start time of the job
   *
   * @param startTime The startTime of the job
   */
  protected synchronized void setStartTime(long startTime) {
    super.setStartTime(startTime);
  }

  /** @param userName The username of the job */
  protected synchronized void setUsername(String userName) {
    super.setUsername(userName);
  }

  /**
   * Used to set the scheduling information associated to a particular Job.
   *
   * @param schedulingInfo Scheduling information of the job
   */
  protected synchronized void setSchedulingInfo(String schedulingInfo) {
    super.setSchedulingInfo(schedulingInfo);
  }

  protected synchronized void setJobACLs(Map<JobACL, AccessControlList> acls) {
    super.setJobACLs(acls);
  }

  /**
   * Set the priority of the job, defaulting to NORMAL.
   *
   * @param jp new job priority
   */
  public synchronized void setJobPriority(JobPriority jp) {
    super.setPriority(org.apache.hadoop.mapreduce.JobPriority.valueOf(jp.name()));
  }

  /** @return Percentage of progress in maps */
  public synchronized float mapProgress() {
    return super.getMapProgress();
  }

  /** @return Percentage of progress in cleanup */
  public synchronized float cleanupProgress() {
    return super.getCleanupProgress();
  }

  /** @return Percentage of progress in setup */
  public synchronized float setupProgress() {
    return super.getSetupProgress();
  }

  /** @return Percentage of progress in reduce */
  public synchronized float reduceProgress() {
    return super.getReduceProgress();
  }

  // A utility to convert new job runstates to the old ones.
  static int getOldNewJobRunState(org.apache.hadoop.mapreduce.JobStatus.State state) {
    return state.getValue();
  }
}