ClusterStatus.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 java.util.ArrayList;
  23. import java.util.Collection;
  24. import org.apache.hadoop.io.Text;
  25. import org.apache.hadoop.io.Writable;
  26. import org.apache.hadoop.io.WritableUtils;
  27. /**
  28.  * Status information on the current state of the Map-Reduce cluster.
  29.  * 
  30.  * <p><code>ClusterStatus</code> provides clients with information such as:
  31.  * <ol>
  32.  *   <li>
  33.  *   Size of the cluster. 
  34.  *   </li>
  35.  *   <li>
  36.  *   Name of the trackers. 
  37.  *   </li>
  38.  *   <li>
  39.  *   Task capacity of the cluster. 
  40.  *   </li>
  41.  *   <li>
  42.  *   The number of currently running map & reduce tasks.
  43.  *   </li>
  44.  *   <li>
  45.  *   State of the <code>JobTracker</code>.
  46.  *   </li>
  47.  * </ol></p>
  48.  * 
  49.  * <p>Clients can query for the latest <code>ClusterStatus</code>, via 
  50.  * {@link JobClient#getClusterStatus()}.</p>
  51.  * 
  52.  * @see JobClient
  53.  */
  54. public class ClusterStatus implements Writable {
  55.   private int numActiveTrackers;
  56.   private Collection<String> activeTrackers = new ArrayList<String>();
  57.   private Collection<String> blacklistedTrackers = new ArrayList<String>();
  58.   private int numBlacklistedTrackers;
  59.   private long ttExpiryInterval;
  60.   private int map_tasks;
  61.   private int reduce_tasks;
  62.   private int max_map_tasks;
  63.   private int max_reduce_tasks;
  64.   private JobTracker.State state;
  65.   private long used_memory;
  66.   private long max_memory;
  67.   ClusterStatus() {}
  68.   
  69.   /**
  70.    * Construct a new cluster status.
  71.    * 
  72.    * @param trackers no. of tasktrackers in the cluster
  73.    * @param maps no. of currently running map-tasks in the cluster
  74.    * @param reduces no. of currently running reduce-tasks in the cluster
  75.    * @param maxMaps the maximum no. of map tasks in the cluster
  76.    * @param maxReduces the maximum no. of reduce tasks in the cluster
  77.    * @param state the {@link JobTracker.State} of the <code>JobTracker</code>
  78.    * @deprecated 
  79.    */
  80.   @Deprecated
  81.   ClusterStatus(int trackers, int maps, int reduces, int maxMaps,
  82.                 int maxReduces, JobTracker.State state) {
  83.     this(trackers, 0, JobTracker.TASKTRACKER_EXPIRY_INTERVAL, maps, reduces,
  84.         maxMaps, maxReduces, state);
  85.   }
  86.   
  87.   /**
  88.    * Construct a new cluster status.
  89.    * 
  90.    * @param trackers no. of tasktrackers in the cluster
  91.    * @param blacklists no of blacklisted task trackers in the cluster
  92.    * @param ttExpiryInterval the tasktracker expiry interval
  93.    * @param maps no. of currently running map-tasks in the cluster
  94.    * @param reduces no. of currently running reduce-tasks in the cluster
  95.    * @param maxMaps the maximum no. of map tasks in the cluster
  96.    * @param maxReduces the maximum no. of reduce tasks in the cluster
  97.    * @param state the {@link JobTracker.State} of the <code>JobTracker</code>
  98.    */
  99.   ClusterStatus(int trackers, int blacklists, long ttExpiryInterval, 
  100.                 int maps, int reduces,
  101.                 int maxMaps, int maxReduces, JobTracker.State state) {
  102.     numActiveTrackers = trackers;
  103.     numBlacklistedTrackers = blacklists;
  104.     this.ttExpiryInterval = ttExpiryInterval;
  105.     map_tasks = maps;
  106.     reduce_tasks = reduces;
  107.     max_map_tasks = maxMaps;
  108.     max_reduce_tasks = maxReduces;
  109.     this.state = state;
  110.     used_memory = Runtime.getRuntime().totalMemory();
  111.     max_memory = Runtime.getRuntime().maxMemory();
  112.   }
  113.   /**
  114.    * Construct a new cluster status.
  115.    * 
  116.    * @param activeTrackers active tasktrackers in the cluster
  117.    * @param blacklistedTrackers blacklisted tasktrackers in the cluster
  118.    * @param ttExpiryInterval the tasktracker expiry interval
  119.    * @param maps no. of currently running map-tasks in the cluster
  120.    * @param reduces no. of currently running reduce-tasks in the cluster
  121.    * @param maxMaps the maximum no. of map tasks in the cluster
  122.    * @param maxReduces the maximum no. of reduce tasks in the cluster
  123.    * @param state the {@link JobTracker.State} of the <code>JobTracker</code>
  124.    */
  125.   ClusterStatus(Collection<String> activeTrackers, 
  126.       Collection<String> blacklistedTrackers,
  127.       long ttExpiryInterval,
  128.       int maps, int reduces, int maxMaps, int maxReduces, 
  129.       JobTracker.State state) {
  130.     this(activeTrackers.size(), blacklistedTrackers.size(), ttExpiryInterval, 
  131.         maps, reduces, maxMaps, maxReduces, state);
  132.     this.activeTrackers = activeTrackers;
  133.     this.blacklistedTrackers = blacklistedTrackers;
  134.   }
  135.   /**
  136.    * Get the number of task trackers in the cluster.
  137.    * 
  138.    * @return the number of task trackers in the cluster.
  139.    */
  140.   public int getTaskTrackers() {
  141.     return numActiveTrackers;
  142.   }
  143.   
  144.   /**
  145.    * Get the names of task trackers in the cluster.
  146.    * 
  147.    * @return the active task trackers in the cluster.
  148.    */
  149.   public Collection<String> getActiveTrackerNames() {
  150.     return activeTrackers;
  151.   }
  152.   /**
  153.    * Get the names of task trackers in the cluster.
  154.    * 
  155.    * @return the blacklisted task trackers in the cluster.
  156.    */
  157.   public Collection<String> getBlacklistedTrackerNames() {
  158.     return blacklistedTrackers;
  159.   }
  160.   
  161.   /**
  162.    * Get the number of blacklisted task trackers in the cluster.
  163.    * 
  164.    * @return the number of blacklisted task trackers in the cluster.
  165.    */
  166.   public int getBlacklistedTrackers() {
  167.     return numBlacklistedTrackers;
  168.   }
  169.   
  170.   /**
  171.    * Get the tasktracker expiry interval for the cluster
  172.    * @return the expiry interval in msec
  173.    */
  174.   public long getTTExpiryInterval() {
  175.     return ttExpiryInterval;
  176.   }
  177.   
  178.   /**
  179.    * Get the number of currently running map tasks in the cluster.
  180.    * 
  181.    * @return the number of currently running map tasks in the cluster.
  182.    */
  183.   public int getMapTasks() {
  184.     return map_tasks;
  185.   }
  186.   
  187.   /**
  188.    * Get the number of currently running reduce tasks in the cluster.
  189.    * 
  190.    * @return the number of currently running reduce tasks in the cluster.
  191.    */
  192.   public int getReduceTasks() {
  193.     return reduce_tasks;
  194.   }
  195.   
  196.   /**
  197.    * Get the maximum capacity for running map tasks in the cluster.
  198.    * 
  199.    * @return the maximum capacity for running map tasks in the cluster.
  200.    */
  201.   public int getMaxMapTasks() {
  202.     return max_map_tasks;
  203.   }
  204.   /**
  205.    * Get the maximum capacity for running reduce tasks in the cluster.
  206.    * 
  207.    * @return the maximum capacity for running reduce tasks in the cluster.
  208.    */
  209.   public int getMaxReduceTasks() {
  210.     return max_reduce_tasks;
  211.   }
  212.   
  213.   /**
  214.    * Get the current state of the <code>JobTracker</code>, 
  215.    * as {@link JobTracker.State}
  216.    * 
  217.    * @return the current state of the <code>JobTracker</code>.
  218.    */
  219.   public JobTracker.State getJobTrackerState() {
  220.     return state;
  221.   }
  222.   /**
  223.    * Get the total heap memory used by the <code>JobTracker</code>
  224.    * 
  225.    * @return the size of heap memory used by the <code>JobTracker</code>
  226.    */
  227.   public long getUsedMemory() {
  228.     return used_memory;
  229.   }
  230.   /**
  231.    * Get the maximum configured heap memory that can be used by the <code>JobTracker</code>
  232.    * 
  233.    * @return the configured size of max heap memory that can be used by the <code>JobTracker</code>
  234.    */
  235.   public long getMaxMemory() {
  236.     return max_memory;
  237.   }
  238.   public void write(DataOutput out) throws IOException {
  239.     if (activeTrackers.size() == 0) {
  240.       out.writeInt(numActiveTrackers);
  241.       out.writeInt(0);
  242.     } else {
  243.       out.writeInt(activeTrackers.size());
  244.       out.writeInt(activeTrackers.size());
  245.       for (String tracker : activeTrackers) {
  246.         Text.writeString(out, tracker);
  247.       }
  248.     }
  249.     if (blacklistedTrackers.size() == 0) {
  250.       out.writeInt(numBlacklistedTrackers);
  251.       out.writeInt(0);
  252.     } else {
  253.       out.writeInt(blacklistedTrackers.size());
  254.       out.writeInt(blacklistedTrackers.size());
  255.       for (String tracker : blacklistedTrackers) {
  256.         Text.writeString(out, tracker);
  257.       }
  258.     }
  259.     out.writeLong(ttExpiryInterval);
  260.     out.writeInt(map_tasks);
  261.     out.writeInt(reduce_tasks);
  262.     out.writeInt(max_map_tasks);
  263.     out.writeInt(max_reduce_tasks);
  264.     out.writeLong(used_memory);
  265.     out.writeLong(max_memory);
  266.     WritableUtils.writeEnum(out, state);
  267.   }
  268.   public void readFields(DataInput in) throws IOException {
  269.     numActiveTrackers = in.readInt();
  270.     int numTrackerNames = in.readInt();
  271.     if (numTrackerNames > 0) {
  272.       for (int i = 0; i < numTrackerNames; i++) {
  273.         String name = Text.readString(in);
  274.         activeTrackers.add(name);
  275.       }
  276.     }
  277.     numBlacklistedTrackers = in.readInt();
  278.     numTrackerNames = in.readInt();
  279.     if (numTrackerNames > 0) {
  280.       for (int i = 0; i < numTrackerNames; i++) {
  281.         String name = Text.readString(in);
  282.         blacklistedTrackers.add(name);
  283.       }
  284.     }
  285.     ttExpiryInterval = in.readLong();
  286.     map_tasks = in.readInt();
  287.     reduce_tasks = in.readInt();
  288.     max_map_tasks = in.readInt();
  289.     max_reduce_tasks = in.readInt();
  290.     used_memory = in.readLong();
  291.     max_memory = in.readLong();
  292.     state = WritableUtils.readEnum(in, JobTracker.State.class);
  293.   }
  294. }