JobStatus.java
上传用户:quxuerui
上传日期:2018-01-08
资源大小:41811k
文件大小:9k
源码类别:

网格计算

开发平台:

Java

  1. /**
  2.  * Licensed to the Apache Software Foundation (ASF) under one
  3.  * or more contributor license agreements.  See the NOTICE file
  4.  * distributed with this work for additional information
  5.  * regarding copyright ownership.  The ASF licenses this file
  6.  * to you under the Apache License, Version 2.0 (the
  7.  * "License"); you may not use this file except in compliance
  8.  * with the License.  You may obtain a copy of the License at
  9.  *
  10.  *     http://www.apache.org/licenses/LICENSE-2.0
  11.  *
  12.  * Unless required by applicable law or agreed to in writing, software
  13.  * distributed under the License is distributed on an "AS IS" BASIS,
  14.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15.  * See the License for the specific language governing permissions and
  16.  * limitations under the License.
  17.  */
  18. package org.apache.hadoop.mapred;
  19. import java.io.DataInput;
  20. import java.io.DataOutput;
  21. import java.io.IOException;
  22. import org.apache.hadoop.io.Text;
  23. import org.apache.hadoop.io.Writable;
  24. import org.apache.hadoop.io.WritableFactories;
  25. import org.apache.hadoop.io.WritableFactory;
  26. import org.apache.hadoop.io.WritableUtils;
  27. /**************************************************
  28.  * Describes the current status of a job.  This is
  29.  * not intended to be a comprehensive piece of data.
  30.  * For that, look at JobProfile.
  31.  **************************************************/
  32. public class JobStatus implements Writable, Cloneable {
  33.   static {                                      // register a ctor
  34.     WritableFactories.setFactory
  35.       (JobStatus.class,
  36.        new WritableFactory() {
  37.          public Writable newInstance() { return new JobStatus(); }
  38.        });
  39.   }
  40.   public static final int RUNNING = 1;
  41.   public static final int SUCCEEDED = 2;
  42.   public static final int FAILED = 3;
  43.   public static final int PREP = 4;
  44.   public static final int KILLED = 5;
  45.   private JobID jobid;
  46.   private float mapProgress;
  47.   private float reduceProgress;
  48.   private float cleanupProgress;
  49.   private float setupProgress;
  50.   private int runState;
  51.   private long startTime;
  52.   private String user;
  53.   private JobPriority priority;
  54.   private String schedulingInfo="NA";
  55.     
  56.   /**
  57.    */
  58.   public JobStatus() {
  59.   }
  60.   /**
  61.    * Create a job status object for a given jobid.
  62.    * @param jobid The jobid of the job
  63.    * @param mapProgress The progress made on the maps
  64.    * @param reduceProgress The progress made on the reduces
  65.    * @param cleanupProgress The progress made on cleanup
  66.    * @param runState The current state of the job
  67.    */
  68.   public JobStatus(JobID jobid, float mapProgress, float reduceProgress,
  69.                    float cleanupProgress, int runState) {
  70.     this(jobid, mapProgress, reduceProgress, cleanupProgress, runState,
  71.                   JobPriority.NORMAL);
  72.   }
  73.   /**
  74.    * Create a job status object for a given jobid.
  75.    * @param jobid The jobid of the job
  76.    * @param mapProgress The progress made on the maps
  77.    * @param reduceProgress The progress made on the reduces
  78.    * @param runState The current state of the job
  79.    */
  80.   public JobStatus(JobID jobid, float mapProgress, float reduceProgress,
  81.                    int runState) {
  82.     this(jobid, mapProgress, reduceProgress, 0.0f, runState);
  83.   }
  84.   /**
  85.    * Create a job status object for a given jobid.
  86.    * @param jobid The jobid of the job
  87.    * @param mapProgress The progress made on the maps
  88.    * @param reduceProgress The progress made on the reduces
  89.    * @param runState The current state of the job
  90.    * @param jp Priority of the job.
  91.    */
  92.    public JobStatus(JobID jobid, float mapProgress, float reduceProgress,
  93.                       float cleanupProgress, int runState, JobPriority jp) {
  94.      this(jobid, 0.0f, mapProgress, reduceProgress, 
  95.           cleanupProgress, runState, jp);
  96.    }
  97.    
  98.   /**
  99.    * Create a job status object for a given jobid.
  100.    * @param jobid The jobid of the job
  101.    * @param setupProgress The progress made on the setup
  102.    * @param mapProgress The progress made on the maps
  103.    * @param reduceProgress The progress made on the reduces
  104.    * @param cleanupProgress The progress made on the cleanup
  105.    * @param runState The current state of the job
  106.    * @param jp Priority of the job.
  107.    */
  108.    public JobStatus(JobID jobid, float setupProgress, float mapProgress,
  109.                     float reduceProgress, float cleanupProgress, 
  110.                     int runState, JobPriority jp) {
  111.      this.jobid = jobid;
  112.      this.setupProgress = setupProgress;
  113.      this.mapProgress = mapProgress;
  114.      this.reduceProgress = reduceProgress;
  115.      this.cleanupProgress = cleanupProgress;
  116.      this.runState = runState;
  117.      this.user = "nobody";
  118.      if (jp == null) {
  119.        throw new IllegalArgumentException("Job Priority cannot be null.");
  120.      }
  121.      priority = jp;
  122.    }
  123.    
  124.   /**
  125.    * @deprecated use getJobID instead
  126.    */
  127.   @Deprecated
  128.   public String getJobId() { return jobid.toString(); }
  129.   
  130.   /**
  131.    * @return The jobid of the Job
  132.    */
  133.   public JobID getJobID() { return jobid; }
  134.     
  135.   /**
  136.    * @return Percentage of progress in maps 
  137.    */
  138.   public synchronized float mapProgress() { return mapProgress; }
  139.     
  140.   /**
  141.    * Sets the map progress of this job
  142.    * @param p The value of map progress to set to
  143.    */
  144.   synchronized void setMapProgress(float p) { 
  145.     this.mapProgress = (float) Math.min(1.0, Math.max(0.0, p)); 
  146.   }
  147.   /**
  148.    * @return Percentage of progress in cleanup 
  149.    */
  150.   public synchronized float cleanupProgress() { return cleanupProgress; }
  151.     
  152.   /**
  153.    * Sets the cleanup progress of this job
  154.    * @param p The value of cleanup progress to set to
  155.    */
  156.   synchronized void setCleanupProgress(float p) { 
  157.     this.cleanupProgress = (float) Math.min(1.0, Math.max(0.0, p)); 
  158.   }
  159.   /**
  160.    * @return Percentage of progress in setup 
  161.    */
  162.   public synchronized float setupProgress() { return setupProgress; }
  163.     
  164.   /**
  165.    * Sets the setup progress of this job
  166.    * @param p The value of setup progress to set to
  167.    */
  168.   synchronized void setSetupProgress(float p) { 
  169.     this.setupProgress = (float) Math.min(1.0, Math.max(0.0, p)); 
  170.   }
  171.   /**
  172.    * @return Percentage of progress in reduce 
  173.    */
  174.   public synchronized float reduceProgress() { return reduceProgress; }
  175.     
  176.   /**
  177.    * Sets the reduce progress of this Job
  178.    * @param p The value of reduce progress to set to
  179.    */
  180.   synchronized void setReduceProgress(float p) { 
  181.     this.reduceProgress = (float) Math.min(1.0, Math.max(0.0, p)); 
  182.   }
  183.     
  184.   /**
  185.    * @return running state of the job
  186.    */
  187.   public synchronized int getRunState() { return runState; }
  188.     
  189.   /**
  190.    * Change the current run state of the job.
  191.    */
  192.   public synchronized void setRunState(int state) {
  193.     this.runState = state;
  194.   }
  195.   /** 
  196.    * Set the start time of the job
  197.    * @param startTime The startTime of the job
  198.    */
  199.   synchronized void setStartTime(long startTime) { this.startTime = startTime;}
  200.     
  201.   /**
  202.    * @return start time of the job
  203.    */
  204.   synchronized public long getStartTime() { return startTime;}
  205.   @Override
  206.   public Object clone() {
  207.     try {
  208.       return super.clone();
  209.     } catch (CloneNotSupportedException cnse) {
  210.       // Shouldn't happen since we do implement Clonable
  211.       throw new InternalError(cnse.toString());
  212.     }
  213.   }
  214.   
  215.   /**
  216.    * @param user The username of the job
  217.    */
  218.   synchronized void setUsername(String userName) { this.user = userName;}
  219.   /**
  220.    * @return the username of the job
  221.    */
  222.   public synchronized String getUsername() { return this.user;}
  223.   
  224.   /**
  225.    * Gets the Scheduling information associated to a particular Job.
  226.    * @return the scheduling information of the job
  227.    */
  228.   public synchronized String getSchedulingInfo() {
  229.    return schedulingInfo;
  230.   }
  231.   /**
  232.    * Used to set the scheduling information associated to a particular Job.
  233.    * 
  234.    * @param schedulingInfo Scheduling information of the job
  235.    */
  236.   public synchronized void setSchedulingInfo(String schedulingInfo) {
  237.     this.schedulingInfo = schedulingInfo;
  238.   }
  239.   
  240.   /**
  241.    * Return the priority of the job
  242.    * @return job priority
  243.    */
  244.    public synchronized JobPriority getJobPriority() { return priority; }
  245.   
  246.   /**
  247.    * Set the priority of the job, defaulting to NORMAL.
  248.    * @param jp new job priority
  249.    */
  250.    public synchronized void setJobPriority(JobPriority jp) {
  251.      if (jp == null) {
  252.        throw new IllegalArgumentException("Job priority cannot be null.");
  253.      }
  254.      priority = jp;
  255.    }
  256.   
  257.    /**
  258.     * Returns true if the status is for a completed job.
  259.     */
  260.    public synchronized boolean isJobComplete() {
  261.      return (runState == JobStatus.SUCCEEDED || runState == JobStatus.FAILED 
  262.              || runState == JobStatus.KILLED);
  263.    }
  264.   ///////////////////////////////////////
  265.   // Writable
  266.   ///////////////////////////////////////
  267.   public synchronized void write(DataOutput out) throws IOException {
  268.     jobid.write(out);
  269.     out.writeFloat(setupProgress);
  270.     out.writeFloat(mapProgress);
  271.     out.writeFloat(reduceProgress);
  272.     out.writeFloat(cleanupProgress);
  273.     out.writeInt(runState);
  274.     out.writeLong(startTime);
  275.     Text.writeString(out, user);
  276.     WritableUtils.writeEnum(out, priority);
  277.     Text.writeString(out, schedulingInfo);
  278.   }
  279.   public synchronized void readFields(DataInput in) throws IOException {
  280.     this.jobid = JobID.read(in);
  281.     this.setupProgress = in.readFloat();
  282.     this.mapProgress = in.readFloat();
  283.     this.reduceProgress = in.readFloat();
  284.     this.cleanupProgress = in.readFloat();
  285.     this.runState = in.readInt();
  286.     this.startTime = in.readLong();
  287.     this.user = Text.readString(in);
  288.     this.priority = WritableUtils.readEnum(in, JobPriority.class);
  289.     this.schedulingInfo = Text.readString(in);
  290.   }
  291. }