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

网格计算

开发平台:

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 java.util.ArrayList;
  23. import java.util.Arrays;
  24. import java.util.Collection;
  25. import org.apache.hadoop.io.Text;
  26. import org.apache.hadoop.io.Writable;
  27. import org.apache.hadoop.io.WritableUtils;
  28. /** A report on the state of a task. */
  29. public class TaskReport implements Writable {
  30.   private TaskID taskid;
  31.   private float progress;
  32.   private String state;
  33.   private String[] diagnostics;
  34.   private long startTime; 
  35.   private long finishTime; 
  36.   private Counters counters;
  37.   private TIPStatus currentStatus;
  38.   
  39.   private Collection<TaskAttemptID> runningAttempts = 
  40.     new ArrayList<TaskAttemptID>();
  41.   private TaskAttemptID successfulAttempt = new TaskAttemptID();
  42.   public TaskReport() {
  43.     taskid = new TaskID();
  44.   }
  45.   
  46.   /**
  47.    * Creates a new TaskReport object
  48.    * @param taskid
  49.    * @param progress
  50.    * @param state
  51.    * @param diagnostics
  52.    * @param startTime
  53.    * @param finishTime
  54.    * @param counters
  55.    * @deprecated
  56.    */
  57.   @Deprecated
  58.   TaskReport(TaskID taskid, float progress, String state,
  59.       String[] diagnostics, long startTime, long finishTime,
  60.       Counters counters) {
  61.     this(taskid, progress, state, diagnostics, null, startTime, finishTime, 
  62.         counters);
  63.   }
  64.   
  65.   /**
  66.    * Creates a new TaskReport object
  67.    * @param taskid
  68.    * @param progress
  69.    * @param state
  70.    * @param diagnostics
  71.    * @param currentStatus
  72.    * @param startTime
  73.    * @param finishTime
  74.    * @param counters
  75.    */
  76.   TaskReport(TaskID taskid, float progress, String state,
  77.              String[] diagnostics, TIPStatus currentStatus, 
  78.              long startTime, long finishTime,
  79.              Counters counters) {
  80.     this.taskid = taskid;
  81.     this.progress = progress;
  82.     this.state = state;
  83.     this.diagnostics = diagnostics;
  84.     this.currentStatus = currentStatus;
  85.     this.startTime = startTime; 
  86.     this.finishTime = finishTime;
  87.     this.counters = counters;
  88.   }
  89.     
  90.   /** @deprecated use {@link #getTaskID()} instead */
  91.   @Deprecated
  92.   public String getTaskId() { return taskid.toString(); }
  93.   /** The id of the task. */
  94.   public TaskID getTaskID() { return taskid; }
  95.   /** The amount completed, between zero and one. */
  96.   public float getProgress() { return progress; }
  97.   /** The most recent state, reported by a {@link Reporter}. */
  98.   public String getState() { return state; }
  99.   /** A list of error messages. */
  100.   public String[] getDiagnostics() { return diagnostics; }
  101.   /** A table of counters. */
  102.   public Counters getCounters() { return counters; }
  103.   /** The current status */
  104.   public TIPStatus getCurrentStatus() {
  105.     return currentStatus;
  106.   }
  107.   
  108.   /**
  109.    * Get finish time of task. 
  110.    * @return 0, if finish time was not set else returns finish time.
  111.    */
  112.   public long getFinishTime() {
  113.     return finishTime;
  114.   }
  115.   /** 
  116.    * set finish time of task. 
  117.    * @param finishTime finish time of task. 
  118.    */
  119.   void setFinishTime(long finishTime) {
  120.     this.finishTime = finishTime;
  121.   }
  122.   /**
  123.    * Get start time of task. 
  124.    * @return 0 if start time was not set, else start time. 
  125.    */
  126.   public long getStartTime() {
  127.     return startTime;
  128.   }
  129.   /** 
  130.    * set start time of the task. 
  131.    */ 
  132.   void setStartTime(long startTime) {
  133.     this.startTime = startTime;
  134.   }
  135.   /** 
  136.    * set successful attempt ID of the task. 
  137.    */ 
  138.   public void setSuccessfulAttempt(TaskAttemptID t) {
  139.     successfulAttempt = t;
  140.   }
  141.   /**
  142.    * Get the attempt ID that took this task to completion
  143.    */
  144.   public TaskAttemptID getSuccessfulTaskAttempt() {
  145.     return successfulAttempt;
  146.   }
  147.   /** 
  148.    * set running attempt(s) of the task. 
  149.    */ 
  150.   public void setRunningTaskAttempts(
  151.       Collection<TaskAttemptID> runningAttempts) {
  152.     this.runningAttempts = runningAttempts;
  153.   }
  154.   /**
  155.    * Get the running task attempt IDs for this task
  156.    */
  157.   public Collection<TaskAttemptID> getRunningTaskAttempts() {
  158.     return runningAttempts;
  159.   }
  160.   @Override
  161.   public boolean equals(Object o) {
  162.     if(o == null)
  163.       return false;
  164.     if(o.getClass().equals(TaskReport.class)) {
  165.       TaskReport report = (TaskReport) o;
  166.       return counters.equals(report.getCounters())
  167.              && Arrays.toString(this.diagnostics)
  168.                       .equals(Arrays.toString(report.getDiagnostics()))
  169.              && this.finishTime == report.getFinishTime()
  170.              && this.progress == report.getProgress()
  171.              && this.startTime == report.getStartTime()
  172.              && this.state.equals(report.getState())
  173.              && this.taskid.equals(report.getTaskID());
  174.     }
  175.     return false; 
  176.   }
  177.   @Override
  178.   public int hashCode() {
  179.     return (counters.toString() + Arrays.toString(this.diagnostics) 
  180.             + this.finishTime + this.progress + this.startTime + this.state 
  181.             + this.taskid.toString()).hashCode();
  182.   }
  183.   //////////////////////////////////////////////
  184.   // Writable
  185.   //////////////////////////////////////////////
  186.   public void write(DataOutput out) throws IOException {
  187.     taskid.write(out);
  188.     out.writeFloat(progress);
  189.     Text.writeString(out, state);
  190.     out.writeLong(startTime);
  191.     out.writeLong(finishTime);
  192.     WritableUtils.writeStringArray(out, diagnostics);
  193.     counters.write(out);
  194.     WritableUtils.writeEnum(out, currentStatus);
  195.     if (currentStatus == TIPStatus.RUNNING) {
  196.       WritableUtils.writeVInt(out, runningAttempts.size());
  197.       TaskAttemptID t[] = new TaskAttemptID[0];
  198.       t = runningAttempts.toArray(t);
  199.       for (int i = 0; i < t.length; i++) {
  200.         t[i].write(out);
  201.       }
  202.     } else if (currentStatus == TIPStatus.COMPLETE) {
  203.       successfulAttempt.write(out);
  204.     }
  205.   }
  206.   public void readFields(DataInput in) throws IOException {
  207.     this.taskid.readFields(in);
  208.     this.progress = in.readFloat();
  209.     this.state = Text.readString(in);
  210.     this.startTime = in.readLong(); 
  211.     this.finishTime = in.readLong();
  212.     
  213.     diagnostics = WritableUtils.readStringArray(in);
  214.     counters = new Counters();
  215.     counters.readFields(in);
  216.     currentStatus = WritableUtils.readEnum(in, TIPStatus.class);
  217.     if (currentStatus == TIPStatus.RUNNING) {
  218.       int num = WritableUtils.readVInt(in);    
  219.       for (int i = 0; i < num; i++) {
  220.         TaskAttemptID t = new TaskAttemptID();
  221.         t.readFields(in);
  222.         runningAttempts.add(t);
  223.       }
  224.     } else if (currentStatus == TIPStatus.COMPLETE) {
  225.       successfulAttempt.readFields(in);
  226.     }
  227.   }
  228. }