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

网格计算

开发平台:

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.hdfs.protocol;
  19. import java.io.DataInput;
  20. import java.io.DataOutput;
  21. import java.io.IOException;
  22. import java.util.Date;
  23. import org.apache.hadoop.io.Text;
  24. import org.apache.hadoop.io.Writable;
  25. import org.apache.hadoop.io.WritableFactories;
  26. import org.apache.hadoop.io.WritableFactory;
  27. import org.apache.hadoop.io.WritableUtils;
  28. import org.apache.hadoop.net.NetworkTopology;
  29. import org.apache.hadoop.net.Node;
  30. import org.apache.hadoop.net.NodeBase;
  31. import org.apache.hadoop.util.StringUtils;
  32. /** 
  33.  * DatanodeInfo represents the status of a DataNode.
  34.  * This object is used for communication in the
  35.  * Datanode Protocol and the Client Protocol.
  36.  */
  37. public class DatanodeInfo extends DatanodeID implements Node {
  38.   protected long capacity;
  39.   protected long dfsUsed;
  40.   protected long remaining;
  41.   protected long lastUpdate;
  42.   protected int xceiverCount;
  43.   protected String location = NetworkTopology.DEFAULT_RACK;
  44.   /** HostName as suplied by the datanode during registration as its 
  45.    * name. Namenode uses datanode IP address as the name.
  46.    */
  47.   protected String hostName = null;
  48.   
  49.   // administrative states of a datanode
  50.   public enum AdminStates {NORMAL, DECOMMISSION_INPROGRESS, DECOMMISSIONED; }
  51.   protected AdminStates adminState;
  52.   public DatanodeInfo() {
  53.     super();
  54.     adminState = null;
  55.   }
  56.   
  57.   public DatanodeInfo(DatanodeInfo from) {
  58.     super(from);
  59.     this.capacity = from.getCapacity();
  60.     this.dfsUsed = from.getDfsUsed();
  61.     this.remaining = from.getRemaining();
  62.     this.lastUpdate = from.getLastUpdate();
  63.     this.xceiverCount = from.getXceiverCount();
  64.     this.location = from.getNetworkLocation();
  65.     this.adminState = from.adminState;
  66.     this.hostName = from.hostName;
  67.   }
  68.   public DatanodeInfo(DatanodeID nodeID) {
  69.     super(nodeID);
  70.     this.capacity = 0L;
  71.     this.dfsUsed = 0L;
  72.     this.remaining = 0L;
  73.     this.lastUpdate = 0L;
  74.     this.xceiverCount = 0;
  75.     this.adminState = null;    
  76.   }
  77.   
  78.   protected DatanodeInfo(DatanodeID nodeID, String location, String hostName) {
  79.     this(nodeID);
  80.     this.location = location;
  81.     this.hostName = hostName;
  82.   }
  83.   
  84.   /** The raw capacity. */
  85.   public long getCapacity() { return capacity; }
  86.   
  87.   /** The used space by the data node. */
  88.   public long getDfsUsed() { return dfsUsed; }
  89.   /** The used space by the data node. */
  90.   public long getNonDfsUsed() { 
  91.     long nonDFSUsed = capacity - dfsUsed - remaining;
  92.     return nonDFSUsed < 0 ? 0 : nonDFSUsed;
  93.   }
  94.   /** The used space by the data node as percentage of present capacity */
  95.   public float getDfsUsedPercent() { 
  96.     if (capacity <= 0) {
  97.       return 100;
  98.     }
  99.     return ((float)dfsUsed * 100.0f)/(float)capacity; 
  100.   }
  101.   /** The raw free space. */
  102.   public long getRemaining() { return remaining; }
  103.   /** The remaining space as percentage of configured capacity. */
  104.   public float getRemainingPercent() { 
  105.     if (capacity <= 0) {
  106.       return 0;
  107.     }
  108.     return ((float)remaining * 100.0f)/(float)capacity; 
  109.   }
  110.   /** The time when this information was accurate. */
  111.   public long getLastUpdate() { return lastUpdate; }
  112.   /** number of active connections */
  113.   public int getXceiverCount() { return xceiverCount; }
  114.   /** Sets raw capacity. */
  115.   public void setCapacity(long capacity) { 
  116.     this.capacity = capacity; 
  117.   }
  118.   /** Sets raw free space. */
  119.   public void setRemaining(long remaining) { 
  120.     this.remaining = remaining; 
  121.   }
  122.   /** Sets time when this information was accurate. */
  123.   public void setLastUpdate(long lastUpdate) { 
  124.     this.lastUpdate = lastUpdate; 
  125.   }
  126.   /** Sets number of active connections */
  127.   public void setXceiverCount(int xceiverCount) { 
  128.     this.xceiverCount = xceiverCount; 
  129.   }
  130.   /** rack name **/
  131.   public synchronized String getNetworkLocation() {return location;}
  132.     
  133.   /** Sets the rack name */
  134.   public synchronized void setNetworkLocation(String location) {
  135.     this.location = NodeBase.normalize(location);
  136.   }
  137.   
  138.   public String getHostName() {
  139.     return (hostName == null || hostName.length()==0) ? getHost() : hostName;
  140.   }
  141.   
  142.   public void setHostName(String host) {
  143.     hostName = host;
  144.   }
  145.   
  146.   /** A formatted string for reporting the status of the DataNode. */
  147.   public String getDatanodeReport() {
  148.     StringBuffer buffer = new StringBuffer();
  149.     long c = getCapacity();
  150.     long r = getRemaining();
  151.     long u = getDfsUsed();
  152.     long nonDFSUsed = getNonDfsUsed();
  153.     float usedPercent = getDfsUsedPercent();
  154.     float remainingPercent = getRemainingPercent();
  155.     buffer.append("Name: "+name+"n");
  156.     if (!NetworkTopology.DEFAULT_RACK.equals(location)) {
  157.       buffer.append("Rack: "+location+"n");
  158.     }
  159.     buffer.append("Decommission Status : ");
  160.     if (isDecommissioned()) {
  161.       buffer.append("Decommissionedn");
  162.     } else if (isDecommissionInProgress()) {
  163.       buffer.append("Decommission in progressn");
  164.     } else {
  165.       buffer.append("Normaln");
  166.     }
  167.     buffer.append("Configured Capacity: "+c+" ("+StringUtils.byteDesc(c)+")"+"n");
  168.     buffer.append("DFS Used: "+u+" ("+StringUtils.byteDesc(u)+")"+"n");
  169.     buffer.append("Non DFS Used: "+nonDFSUsed+" ("+StringUtils.byteDesc(nonDFSUsed)+")"+"n");
  170.     buffer.append("DFS Remaining: " +r+ "("+StringUtils.byteDesc(r)+")"+"n");
  171.     buffer.append("DFS Used%: "+StringUtils.limitDecimalTo2(usedPercent)+"%n");
  172.     buffer.append("DFS Remaining%: "+StringUtils.limitDecimalTo2(remainingPercent)+"%n");
  173.     buffer.append("Last contact: "+new Date(lastUpdate)+"n");
  174.     return buffer.toString();
  175.   }
  176.   /** A formatted string for printing the status of the DataNode. */
  177.   public String dumpDatanode() {
  178.     StringBuffer buffer = new StringBuffer();
  179.     long c = getCapacity();
  180.     long r = getRemaining();
  181.     long u = getDfsUsed();
  182.     buffer.append(name);
  183.     if (!NetworkTopology.DEFAULT_RACK.equals(location)) {
  184.       buffer.append(" "+location);
  185.     }
  186.     if (isDecommissioned()) {
  187.       buffer.append(" DD");
  188.     } else if (isDecommissionInProgress()) {
  189.       buffer.append(" DP");
  190.     } else {
  191.       buffer.append(" IN");
  192.     }
  193.     buffer.append(" " + c + "(" + StringUtils.byteDesc(c)+")");
  194.     buffer.append(" " + u + "(" + StringUtils.byteDesc(u)+")");
  195.     buffer.append(" " + StringUtils.limitDecimalTo2(((1.0*u)/c)*100)+"%");
  196.     buffer.append(" " + r + "(" + StringUtils.byteDesc(r)+")");
  197.     buffer.append(" " + new Date(lastUpdate));
  198.     return buffer.toString();
  199.   }
  200.   /**
  201.    * Start decommissioning a node.
  202.    * old state.
  203.    */
  204.   public void startDecommission() {
  205.     adminState = AdminStates.DECOMMISSION_INPROGRESS;
  206.   }
  207.   /**
  208.    * Stop decommissioning a node.
  209.    * old state.
  210.    */
  211.   public void stopDecommission() {
  212.     adminState = null;
  213.   }
  214.   /**
  215.    * Returns true if the node is in the process of being decommissioned
  216.    */
  217.   public boolean isDecommissionInProgress() {
  218.     if (adminState == AdminStates.DECOMMISSION_INPROGRESS) {
  219.       return true;
  220.     }
  221.     return false;
  222.   }
  223.   /**
  224.    * Returns true if the node has been decommissioned.
  225.    */
  226.   public boolean isDecommissioned() {
  227.     if (adminState == AdminStates.DECOMMISSIONED) {
  228.       return true;
  229.     }
  230.     return false;
  231.   }
  232.   /**
  233.    * Sets the admin state to indicate that decommision is complete.
  234.    */
  235.   public void setDecommissioned() {
  236.     adminState = AdminStates.DECOMMISSIONED;
  237.   }
  238.   /**
  239.    * Retrieves the admin state of this node.
  240.    */
  241.   AdminStates getAdminState() {
  242.     if (adminState == null) {
  243.       return AdminStates.NORMAL;
  244.     }
  245.     return adminState;
  246.   }
  247.   /**
  248.    * Sets the admin state of this node.
  249.    */
  250.   protected void setAdminState(AdminStates newState) {
  251.     if (newState == AdminStates.NORMAL) {
  252.       adminState = null;
  253.     }
  254.     else {
  255.       adminState = newState;
  256.     }
  257.   }
  258.   private int level; //which level of the tree the node resides
  259.   private Node parent; //its parent
  260.   /** Return this node's parent */
  261.   public Node getParent() { return parent; }
  262.   public void setParent(Node parent) {this.parent = parent;}
  263.    
  264.   /** Return this node's level in the tree.
  265.    * E.g. the root of a tree returns 0 and its children return 1
  266.    */
  267.   public int getLevel() { return level; }
  268.   public void setLevel(int level) {this.level = level;}
  269.   /////////////////////////////////////////////////
  270.   // Writable
  271.   /////////////////////////////////////////////////
  272.   static {                                      // register a ctor
  273.     WritableFactories.setFactory
  274.       (DatanodeInfo.class,
  275.        new WritableFactory() {
  276.          public Writable newInstance() { return new DatanodeInfo(); }
  277.        });
  278.   }
  279.   /** {@inheritDoc} */
  280.   public void write(DataOutput out) throws IOException {
  281.     super.write(out);
  282.     //TODO: move it to DatanodeID once DatanodeID is not stored in FSImage
  283.     out.writeShort(ipcPort);
  284.     out.writeLong(capacity);
  285.     out.writeLong(dfsUsed);
  286.     out.writeLong(remaining);
  287.     out.writeLong(lastUpdate);
  288.     out.writeInt(xceiverCount);
  289.     Text.writeString(out, location);
  290.     Text.writeString(out, hostName == null? "": hostName);
  291.     WritableUtils.writeEnum(out, getAdminState());
  292.   }
  293.   /** {@inheritDoc} */
  294.   public void readFields(DataInput in) throws IOException {
  295.     super.readFields(in);
  296.     //TODO: move it to DatanodeID once DatanodeID is not stored in FSImage
  297.     this.ipcPort = in.readShort() & 0x0000ffff;
  298.     this.capacity = in.readLong();
  299.     this.dfsUsed = in.readLong();
  300.     this.remaining = in.readLong();
  301.     this.lastUpdate = in.readLong();
  302.     this.xceiverCount = in.readInt();
  303.     this.location = Text.readString(in);
  304.     this.hostName = Text.readString(in);
  305.     setAdminState(WritableUtils.readEnum(in, AdminStates.class));
  306.   }
  307. }