| /** |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| package org.apache.hadoop.hdfs.protocol; |
| |
| import org.apache.hadoop.classification.InterfaceAudience; |
| import org.apache.hadoop.classification.InterfaceStability; |
| import org.apache.hadoop.hdfs.DFSUtilClient; |
| import org.apache.hadoop.net.NetUtils; |
| import org.apache.hadoop.net.NetworkTopology; |
| import org.apache.hadoop.net.Node; |
| import org.apache.hadoop.net.NodeBase; |
| import org.apache.hadoop.util.StringUtils; |
| import org.apache.hadoop.util.Time; |
| |
| import java.util.Date; |
| import java.util.LinkedList; |
| import java.util.List; |
| |
| import static org.apache.hadoop.hdfs.DFSUtilClient.percent2String; |
| |
| /** |
| * This class extends the primary identifier of a Datanode with ephemeral |
| * state, eg usage information, current administrative state, and the |
| * network location that is communicated to clients. |
| */ |
| @InterfaceAudience.Private |
| @InterfaceStability.Evolving |
| public class DatanodeInfo extends DatanodeID implements Node { |
| private long capacity; |
| private long dfsUsed; |
| private long nonDfsUsed; |
| private long remaining; |
| private long blockPoolUsed; |
| private long cacheCapacity; |
| private long cacheUsed; |
| private long lastUpdate; |
| private long lastUpdateMonotonic; |
| private int xceiverCount; |
| private volatile String location = NetworkTopology.DEFAULT_RACK; |
| private String softwareVersion; |
| private List<String> dependentHostNames = new LinkedList<>(); |
| private String upgradeDomain; |
| public static final DatanodeInfo[] EMPTY_ARRAY = {}; |
| |
| // Datanode administrative states |
| public enum AdminStates { |
| NORMAL("In Service"), |
| DECOMMISSION_INPROGRESS("Decommission In Progress"), |
| DECOMMISSIONED("Decommissioned"), |
| ENTERING_MAINTENANCE("Entering Maintenance"), |
| IN_MAINTENANCE("In Maintenance"); |
| |
| final String value; |
| |
| AdminStates(final String v) { |
| this.value = v; |
| } |
| |
| @Override |
| public String toString() { |
| return value; |
| } |
| |
| public static AdminStates fromValue(final String value) { |
| for (AdminStates as : AdminStates.values()) { |
| if (as.value.equals(value)) return as; |
| } |
| return NORMAL; |
| } |
| } |
| |
| protected AdminStates adminState; |
| private long maintenanceExpireTimeInMS; |
| private long lastBlockReportTime; |
| private long lastBlockReportMonotonic; |
| |
| protected DatanodeInfo(DatanodeInfo from) { |
| super(from); |
| this.capacity = from.getCapacity(); |
| this.dfsUsed = from.getDfsUsed(); |
| this.nonDfsUsed = from.getNonDfsUsed(); |
| this.remaining = from.getRemaining(); |
| this.blockPoolUsed = from.getBlockPoolUsed(); |
| this.cacheCapacity = from.getCacheCapacity(); |
| this.cacheUsed = from.getCacheUsed(); |
| this.lastUpdate = from.getLastUpdate(); |
| this.lastUpdateMonotonic = from.getLastUpdateMonotonic(); |
| this.xceiverCount = from.getXceiverCount(); |
| this.location = from.getNetworkLocation(); |
| this.adminState = from.getAdminState(); |
| this.upgradeDomain = from.getUpgradeDomain(); |
| this.lastBlockReportTime = from.getLastBlockReportTime(); |
| this.lastBlockReportMonotonic = from.getLastBlockReportMonotonic(); |
| } |
| |
| protected DatanodeInfo(DatanodeID nodeID) { |
| super(nodeID); |
| this.capacity = 0L; |
| this.dfsUsed = 0L; |
| this.nonDfsUsed = 0L; |
| this.remaining = 0L; |
| this.blockPoolUsed = 0L; |
| this.cacheCapacity = 0L; |
| this.cacheUsed = 0L; |
| this.lastUpdate = 0L; |
| this.lastUpdateMonotonic = 0L; |
| this.xceiverCount = 0; |
| this.adminState = null; |
| this.lastBlockReportTime = 0L; |
| this.lastBlockReportMonotonic = 0L; |
| } |
| |
| protected DatanodeInfo(DatanodeID nodeID, String location) { |
| this(nodeID); |
| this.location = location; |
| } |
| |
| /** Constructor. */ |
| private DatanodeInfo(final String ipAddr, final String hostName, |
| final String datanodeUuid, final int xferPort, final int infoPort, |
| final int infoSecurePort, final int ipcPort, final long capacity, |
| final long dfsUsed, final long nonDfsUsed, final long remaining, |
| final long blockPoolUsed, final long cacheCapacity, final long cacheUsed, |
| final long lastUpdate, final long lastUpdateMonotonic, |
| final int xceiverCount, final String networkLocation, |
| final AdminStates adminState, final String upgradeDomain, |
| final long lastBlockReportTime, final long lastBlockReportMonotonic) { |
| super(ipAddr, hostName, datanodeUuid, xferPort, infoPort, infoSecurePort, |
| ipcPort); |
| this.capacity = capacity; |
| this.dfsUsed = dfsUsed; |
| this.nonDfsUsed = nonDfsUsed; |
| this.remaining = remaining; |
| this.blockPoolUsed = blockPoolUsed; |
| this.cacheCapacity = cacheCapacity; |
| this.cacheUsed = cacheUsed; |
| this.lastUpdate = lastUpdate; |
| this.lastUpdateMonotonic = lastUpdateMonotonic; |
| this.xceiverCount = xceiverCount; |
| this.location = networkLocation; |
| this.adminState = adminState; |
| this.upgradeDomain = upgradeDomain; |
| this.lastBlockReportTime = lastBlockReportTime; |
| this.lastBlockReportMonotonic = lastBlockReportMonotonic; |
| } |
| |
| /** Network location name. */ |
| @Override |
| public String getName() { |
| return getXferAddr(); |
| } |
| |
| /** The raw capacity. */ |
| public long getCapacity() { return capacity; } |
| |
| /** The used space by the data node. */ |
| public long getDfsUsed() { return dfsUsed; } |
| |
| /** The used space by the block pool on data node. */ |
| public long getBlockPoolUsed() { return blockPoolUsed; } |
| |
| /** The used space by the data node. */ |
| public long getNonDfsUsed() { |
| return nonDfsUsed; |
| } |
| |
| /** The used space by the data node as percentage of present capacity */ |
| public float getDfsUsedPercent() { |
| return DFSUtilClient.getPercentUsed(dfsUsed, capacity); |
| } |
| |
| /** The raw free space. */ |
| public long getRemaining() { return remaining; } |
| |
| /** Used space by the block pool as percentage of present capacity */ |
| public float getBlockPoolUsedPercent() { |
| return DFSUtilClient.getPercentUsed(blockPoolUsed, capacity); |
| } |
| |
| /** The remaining space as percentage of configured capacity. */ |
| public float getRemainingPercent() { |
| return DFSUtilClient.getPercentRemaining(remaining, capacity); |
| } |
| |
| /** |
| * @return Amount of cache capacity in bytes |
| */ |
| public long getCacheCapacity() { |
| return cacheCapacity; |
| } |
| |
| /** |
| * @return Amount of cache used in bytes |
| */ |
| public long getCacheUsed() { |
| return cacheUsed; |
| } |
| |
| /** |
| * @return Cache used as a percentage of the datanode's total cache capacity |
| */ |
| public float getCacheUsedPercent() { |
| return DFSUtilClient.getPercentUsed(cacheUsed, cacheCapacity); |
| } |
| |
| /** |
| * @return Amount of cache remaining in bytes |
| */ |
| public long getCacheRemaining() { |
| return cacheCapacity - cacheUsed; |
| } |
| |
| /** |
| * @return Cache remaining as a percentage of the datanode's total cache |
| * capacity |
| */ |
| public float getCacheRemainingPercent() { |
| return DFSUtilClient.getPercentRemaining(getCacheRemaining(), cacheCapacity); |
| } |
| |
| /** |
| * Get the last update timestamp. |
| * Return value is suitable for Date conversion. |
| */ |
| public long getLastUpdate() { return lastUpdate; } |
| |
| /** |
| * The time when this information was accurate. <br> |
| * Ps: So return value is ideal for calculation of time differences. |
| * Should not be used to convert to Date. |
| */ |
| public long getLastUpdateMonotonic() { return lastUpdateMonotonic;} |
| |
| /** |
| * Set lastUpdate monotonic time |
| */ |
| public void setLastUpdateMonotonic(long lastUpdateMonotonic) { |
| this.lastUpdateMonotonic = lastUpdateMonotonic; |
| } |
| |
| /** number of active connections */ |
| public int getXceiverCount() { return xceiverCount; } |
| |
| /** Sets raw capacity. */ |
| public void setCapacity(long capacity) { |
| this.capacity = capacity; |
| } |
| |
| /** Sets the used space for the datanode. */ |
| public void setDfsUsed(long dfsUsed) { |
| this.dfsUsed = dfsUsed; |
| } |
| |
| /** Sets the nondfs-used space for the datanode. */ |
| public void setNonDfsUsed(long nonDfsUsed) { |
| this.nonDfsUsed = nonDfsUsed; |
| } |
| |
| /** Sets raw free space. */ |
| public void setRemaining(long remaining) { |
| this.remaining = remaining; |
| } |
| |
| /** Sets block pool used space */ |
| public void setBlockPoolUsed(long bpUsed) { |
| this.blockPoolUsed = bpUsed; |
| } |
| |
| /** Sets cache capacity. */ |
| public void setCacheCapacity(long cacheCapacity) { |
| this.cacheCapacity = cacheCapacity; |
| } |
| |
| /** Sets cache used. */ |
| public void setCacheUsed(long cacheUsed) { |
| this.cacheUsed = cacheUsed; |
| } |
| |
| /** Sets time when this information was accurate. */ |
| public void setLastUpdate(long lastUpdate) { |
| this.lastUpdate = lastUpdate; |
| } |
| |
| /** Sets number of active connections */ |
| public void setXceiverCount(int xceiverCount) { |
| this.xceiverCount = xceiverCount; |
| } |
| |
| /** network location */ |
| @Override |
| public String getNetworkLocation() {return location;} |
| |
| /** Sets the network location */ |
| @Override |
| public void setNetworkLocation(String location) { |
| this.location = NodeBase.normalize(location); |
| } |
| |
| /** Sets the upgrade domain */ |
| public void setUpgradeDomain(String upgradeDomain) { |
| this.upgradeDomain = upgradeDomain; |
| } |
| |
| /** upgrade domain */ |
| public String getUpgradeDomain() { |
| return upgradeDomain; |
| } |
| |
| /** Add a hostname to a list of network dependencies */ |
| public void addDependentHostName(String hostname) { |
| dependentHostNames.add(hostname); |
| } |
| |
| /** List of Network dependencies */ |
| public List<String> getDependentHostNames() { |
| return dependentHostNames; |
| } |
| |
| /** Sets the network dependencies */ |
| public void setDependentHostNames(List<String> dependencyList) { |
| dependentHostNames = dependencyList; |
| } |
| |
| /** A formatted string for reporting the status of the DataNode. */ |
| public String getDatanodeReport() { |
| StringBuilder buffer = new StringBuilder(); |
| long c = getCapacity(); |
| long r = getRemaining(); |
| long u = getDfsUsed(); |
| long nonDFSUsed = getNonDfsUsed(); |
| float usedPercent = getDfsUsedPercent(); |
| float remainingPercent = getRemainingPercent(); |
| long cc = getCacheCapacity(); |
| long cr = getCacheRemaining(); |
| long cu = getCacheUsed(); |
| float cacheUsedPercent = getCacheUsedPercent(); |
| float cacheRemainingPercent = getCacheRemainingPercent(); |
| String lookupName = NetUtils.getHostNameOfIP(getName()); |
| |
| buffer.append("Name: ").append(getName()); |
| if (lookupName != null) { |
| buffer.append(" (").append(lookupName).append(")"); |
| } |
| buffer.append("\n"); |
| buffer.append("Hostname: ").append(getHostName()).append("\n"); |
| |
| if (!NetworkTopology.DEFAULT_RACK.equals(location)) { |
| buffer.append("Rack: ").append(location).append("\n"); |
| } |
| if (upgradeDomain != null) { |
| buffer.append("Upgrade domain: ").append(upgradeDomain).append("\n"); |
| } |
| buffer.append("Decommission Status : "); |
| if (isDecommissioned()) { |
| buffer.append("Decommissioned\n"); |
| } else if (isDecommissionInProgress()) { |
| buffer.append("Decommission in progress\n"); |
| } else if (isInMaintenance()) { |
| buffer.append("In maintenance\n"); |
| } else if (isEnteringMaintenance()) { |
| buffer.append("Entering maintenance\n"); |
| } else { |
| buffer.append("Normal\n"); |
| } |
| buffer.append("Configured Capacity: ").append(c).append(" (") |
| .append(StringUtils.byteDesc(c)).append(")").append("\n"); |
| buffer.append("DFS Used: ").append(u).append(" (") |
| .append(StringUtils.byteDesc(u)).append(")").append("\n"); |
| buffer.append("Non DFS Used: ").append(nonDFSUsed).append(" (") |
| .append(StringUtils.byteDesc(nonDFSUsed)).append(")").append("\n"); |
| buffer.append("DFS Remaining: ").append(r).append(" (") |
| .append(StringUtils.byteDesc(r)).append(")").append("\n"); |
| buffer.append("DFS Used%: ").append(percent2String(usedPercent)) |
| .append("\n"); |
| buffer.append("DFS Remaining%: ").append(percent2String(remainingPercent)) |
| .append("\n"); |
| buffer.append("Configured Cache Capacity: ").append(cc).append(" (") |
| .append(StringUtils.byteDesc(cc)).append(")").append("\n"); |
| buffer.append("Cache Used: ").append(cu).append(" (") |
| .append(StringUtils.byteDesc(cu)).append(")").append("\n"); |
| buffer.append("Cache Remaining: ").append(cr).append(" (") |
| .append(StringUtils.byteDesc(cr)).append(")").append("\n"); |
| buffer.append("Cache Used%: ").append(percent2String(cacheUsedPercent)) |
| .append("\n"); |
| buffer.append("Cache Remaining%: ") |
| .append(percent2String(cacheRemainingPercent)).append("\n"); |
| buffer.append("Xceivers: ").append(getXceiverCount()).append("\n"); |
| buffer.append("Last contact: ").append(new Date(lastUpdate)).append("\n"); |
| buffer |
| .append("Last Block Report: ") |
| .append( |
| lastBlockReportTime != 0 ? new Date(lastBlockReportTime) : "Never") |
| .append("\n"); |
| return buffer.toString(); |
| } |
| |
| /** A formatted string for printing the status of the DataNode. */ |
| public String dumpDatanode() { |
| StringBuilder buffer = new StringBuilder(); |
| long c = getCapacity(); |
| long r = getRemaining(); |
| long u = getDfsUsed(); |
| float usedPercent = getDfsUsedPercent(); |
| long cc = getCacheCapacity(); |
| long cr = getCacheRemaining(); |
| long cu = getCacheUsed(); |
| float cacheUsedPercent = getCacheUsedPercent(); |
| buffer.append(getName()); |
| if (!NetworkTopology.DEFAULT_RACK.equals(location)) { |
| buffer.append(" ").append(location); |
| } |
| if (upgradeDomain != null) { |
| buffer.append(" ").append(upgradeDomain); |
| } |
| if (isDecommissioned()) { |
| buffer.append(" DD"); |
| } else if (isDecommissionInProgress()) { |
| buffer.append(" DP"); |
| } else if (isInMaintenance()) { |
| buffer.append(" IM"); |
| } else if (isEnteringMaintenance()) { |
| buffer.append(" EM"); |
| } else { |
| buffer.append(" IN"); |
| } |
| buffer.append(" ").append(c).append("(").append(StringUtils.byteDesc(c)) |
| .append(")"); |
| buffer.append(" ").append(u).append("(").append(StringUtils.byteDesc(u)) |
| .append(")"); |
| buffer.append(" ").append(percent2String(usedPercent)); |
| buffer.append(" ").append(r).append("(").append(StringUtils.byteDesc(r)) |
| .append(")"); |
| buffer.append(" ").append(cc).append("(").append(StringUtils.byteDesc(cc)) |
| .append(")"); |
| buffer.append(" ").append(cu).append("(").append(StringUtils.byteDesc(cu)) |
| .append(")"); |
| buffer.append(" ").append(percent2String(cacheUsedPercent)); |
| buffer.append(" ").append(cr).append("(").append(StringUtils.byteDesc(cr)) |
| .append(")"); |
| buffer.append(" ").append(new Date(lastUpdate)); |
| return buffer.toString(); |
| } |
| |
| /** |
| * Start decommissioning a node. |
| * old state. |
| */ |
| public void startDecommission() { |
| adminState = AdminStates.DECOMMISSION_INPROGRESS; |
| } |
| |
| /** |
| * Stop decommissioning a node. |
| * old state. |
| */ |
| public void stopDecommission() { |
| adminState = null; |
| } |
| |
| /** |
| * Returns true if the node is in the process of being decommissioned |
| */ |
| public boolean isDecommissionInProgress() { |
| return adminState == AdminStates.DECOMMISSION_INPROGRESS; |
| } |
| |
| /** |
| * Returns true if the node has been decommissioned. |
| */ |
| public boolean isDecommissioned() { |
| return adminState == AdminStates.DECOMMISSIONED; |
| } |
| |
| /** |
| * Sets the admin state to indicate that decommission is complete. |
| */ |
| public void setDecommissioned() { |
| adminState = AdminStates.DECOMMISSIONED; |
| } |
| |
| /** |
| * Start the maintenance operation. |
| */ |
| public void startMaintenance() { |
| this.adminState = AdminStates.ENTERING_MAINTENANCE; |
| } |
| |
| /** |
| * Put a node directly to maintenance mode. |
| */ |
| public void setInMaintenance() { |
| this.adminState = AdminStates.IN_MAINTENANCE; |
| } |
| |
| /** |
| * @param maintenanceExpireTimeInMS the time that the DataNode is in the |
| * maintenance mode until in the unit of milliseconds. */ |
| public void setMaintenanceExpireTimeInMS(long maintenanceExpireTimeInMS) { |
| this.maintenanceExpireTimeInMS = maintenanceExpireTimeInMS; |
| } |
| |
| public long getMaintenanceExpireTimeInMS() { |
| return this.maintenanceExpireTimeInMS; |
| } |
| |
| /** Sets the last block report time. */ |
| public void setLastBlockReportTime(long lastBlockReportTime) { |
| this.lastBlockReportTime = lastBlockReportTime; |
| } |
| |
| /** Sets the last block report monotonic time. */ |
| public void setLastBlockReportMonotonic(long lastBlockReportMonotonic) { |
| this.lastBlockReportMonotonic = lastBlockReportMonotonic; |
| } |
| |
| /** Last block report time. */ |
| public long getLastBlockReportTime() { |
| return lastBlockReportTime; |
| } |
| |
| /** Last block report monotonic time. */ |
| public long getLastBlockReportMonotonic() { |
| return lastBlockReportMonotonic; |
| } |
| |
| /** |
| * Take the node out of maintenance mode. |
| */ |
| public void stopMaintenance() { |
| adminState = null; |
| } |
| |
| public static boolean maintenanceNotExpired(long maintenanceExpireTimeInMS) { |
| return Time.now() < maintenanceExpireTimeInMS; |
| } |
| /** |
| * Returns true if the node is is entering_maintenance |
| */ |
| public boolean isEnteringMaintenance() { |
| return adminState == AdminStates.ENTERING_MAINTENANCE; |
| } |
| |
| /** |
| * Returns true if the node is in maintenance |
| */ |
| public boolean isInMaintenance() { |
| return adminState == AdminStates.IN_MAINTENANCE; |
| } |
| |
| /** |
| * Returns true if the node is entering or in maintenance |
| */ |
| public boolean isMaintenance() { |
| return (adminState == AdminStates.ENTERING_MAINTENANCE || |
| adminState == AdminStates.IN_MAINTENANCE); |
| } |
| |
| public boolean maintenanceExpired() { |
| return !maintenanceNotExpired(this.maintenanceExpireTimeInMS); |
| } |
| |
| public boolean isInService() { |
| return getAdminState() == AdminStates.NORMAL; |
| } |
| |
| /** |
| * Retrieves the admin state of this node. |
| */ |
| public AdminStates getAdminState() { |
| if (adminState == null) { |
| return AdminStates.NORMAL; |
| } |
| return adminState; |
| } |
| |
| /** |
| * Check if the datanode is in stale state. Here if |
| * the namenode has not received heartbeat msg from a |
| * datanode for more than staleInterval, |
| * the datanode will be treated as stale node. |
| * |
| * @param staleInterval |
| * the time interval for marking the node as stale. If the last |
| * update time is beyond the given time interval, the node will be |
| * marked as stale. |
| * @return true if the node is stale |
| */ |
| public boolean isStale(long staleInterval) { |
| return (Time.monotonicNow() - lastUpdateMonotonic) >= staleInterval; |
| } |
| |
| /** |
| * Sets the admin state of this node. |
| */ |
| protected void setAdminState(AdminStates newState) { |
| if (newState == AdminStates.NORMAL) { |
| adminState = null; |
| } |
| else { |
| adminState = newState; |
| } |
| } |
| |
| private transient int level; //which level of the tree the node resides |
| private transient Node parent; //its parent |
| |
| /** Return this node's parent */ |
| @Override |
| public Node getParent() { return parent; } |
| @Override |
| public void setParent(Node parent) {this.parent = parent;} |
| |
| /** Return this node's level in the tree. |
| * E.g. the root of a tree returns 0 and its children return 1 |
| */ |
| @Override |
| public int getLevel() { return level; } |
| @Override |
| public void setLevel(int level) {this.level = level;} |
| |
| @Override |
| public int hashCode() { |
| // Super implementation is sufficient |
| return super.hashCode(); |
| } |
| |
| @Override |
| public boolean equals(Object obj) { |
| // Sufficient to use super equality as datanodes are uniquely identified |
| // by DatanodeID |
| return (this == obj) || super.equals(obj); |
| } |
| |
| public String getSoftwareVersion() { |
| return softwareVersion; |
| } |
| |
| public void setSoftwareVersion(String softwareVersion) { |
| this.softwareVersion = softwareVersion; |
| } |
| |
| /** |
| * Building the DataNodeInfo. |
| */ |
| public static class DatanodeInfoBuilder { |
| private String location = NetworkTopology.DEFAULT_RACK; |
| private long capacity; |
| private long dfsUsed; |
| private long remaining; |
| private long blockPoolUsed; |
| private long cacheCapacity; |
| private long cacheUsed; |
| private long lastUpdate; |
| private long lastUpdateMonotonic; |
| private int xceiverCount; |
| private DatanodeInfo.AdminStates adminState; |
| private String upgradeDomain; |
| private String ipAddr; |
| private String hostName; |
| private String datanodeUuid; |
| private int xferPort; |
| private int infoPort; |
| private int infoSecurePort; |
| private int ipcPort; |
| private long nonDfsUsed = 0L; |
| private long lastBlockReportTime = 0L; |
| private long lastBlockReportMonotonic = 0L; |
| |
| public DatanodeInfoBuilder setFrom(DatanodeInfo from) { |
| this.capacity = from.getCapacity(); |
| this.dfsUsed = from.getDfsUsed(); |
| this.nonDfsUsed = from.getNonDfsUsed(); |
| this.remaining = from.getRemaining(); |
| this.blockPoolUsed = from.getBlockPoolUsed(); |
| this.cacheCapacity = from.getCacheCapacity(); |
| this.cacheUsed = from.getCacheUsed(); |
| this.lastUpdate = from.getLastUpdate(); |
| this.lastUpdateMonotonic = from.getLastUpdateMonotonic(); |
| this.xceiverCount = from.getXceiverCount(); |
| this.location = from.getNetworkLocation(); |
| this.adminState = from.getAdminState(); |
| this.upgradeDomain = from.getUpgradeDomain(); |
| this.lastBlockReportTime = from.getLastBlockReportTime(); |
| this.lastBlockReportMonotonic = from.getLastBlockReportMonotonic(); |
| setNodeID(from); |
| return this; |
| } |
| |
| public DatanodeInfoBuilder setNodeID(DatanodeID nodeID) { |
| this.ipAddr = nodeID.getIpAddr(); |
| this.hostName = nodeID.getHostName(); |
| this.datanodeUuid = nodeID.getDatanodeUuid(); |
| this.xferPort = nodeID.getXferPort(); |
| this.infoPort = nodeID.getInfoPort(); |
| this.infoSecurePort = nodeID.getInfoSecurePort(); |
| this.ipcPort = nodeID.getIpcPort(); |
| return this; |
| } |
| |
| public DatanodeInfoBuilder setCapacity(long capacity) { |
| this.capacity = capacity; |
| return this; |
| } |
| |
| public DatanodeInfoBuilder setDfsUsed(long dfsUsed) { |
| this.dfsUsed = dfsUsed; |
| return this; |
| } |
| |
| public DatanodeInfoBuilder setRemaining(long remaining) { |
| this.remaining = remaining; |
| return this; |
| } |
| |
| public DatanodeInfoBuilder setBlockPoolUsed(long blockPoolUsed) { |
| this.blockPoolUsed = blockPoolUsed; |
| return this; |
| } |
| |
| public DatanodeInfoBuilder setCacheCapacity(long cacheCapacity) { |
| this.cacheCapacity = cacheCapacity; |
| return this; |
| } |
| |
| public DatanodeInfoBuilder setCacheUsed(long cacheUsed) { |
| this.cacheUsed = cacheUsed; |
| return this; |
| } |
| |
| public DatanodeInfoBuilder setLastUpdate(long lastUpdate) { |
| this.lastUpdate = lastUpdate; |
| return this; |
| } |
| |
| public DatanodeInfoBuilder setLastUpdateMonotonic( |
| long lastUpdateMonotonic) { |
| this.lastUpdateMonotonic = lastUpdateMonotonic; |
| return this; |
| } |
| |
| public DatanodeInfoBuilder setXceiverCount(int xceiverCount) { |
| this.xceiverCount = xceiverCount; |
| return this; |
| } |
| |
| public DatanodeInfoBuilder setAdminState( |
| DatanodeInfo.AdminStates adminState) { |
| this.adminState = adminState; |
| return this; |
| } |
| |
| public DatanodeInfoBuilder setUpgradeDomain(String upgradeDomain) { |
| this.upgradeDomain = upgradeDomain; |
| return this; |
| } |
| |
| public DatanodeInfoBuilder setIpAddr(String ipAddr) { |
| this.ipAddr = ipAddr; |
| return this; |
| } |
| |
| public DatanodeInfoBuilder setHostName(String hostName) { |
| this.hostName = hostName; |
| return this; |
| } |
| |
| public DatanodeInfoBuilder setDatanodeUuid(String datanodeUuid) { |
| this.datanodeUuid = datanodeUuid; |
| return this; |
| } |
| |
| public DatanodeInfoBuilder setXferPort(int xferPort) { |
| this.xferPort = xferPort; |
| return this; |
| } |
| |
| public DatanodeInfoBuilder setInfoPort(int infoPort) { |
| this.infoPort = infoPort; |
| return this; |
| } |
| |
| public DatanodeInfoBuilder setInfoSecurePort(int infoSecurePort) { |
| this.infoSecurePort = infoSecurePort; |
| return this; |
| } |
| |
| public DatanodeInfoBuilder setIpcPort(int ipcPort) { |
| this.ipcPort = ipcPort; |
| return this; |
| } |
| |
| public DatanodeInfoBuilder setNetworkLocation(String networkLocation) { |
| this.location = networkLocation; |
| return this; |
| } |
| |
| public DatanodeInfoBuilder setNonDfsUsed(long nonDfsUsed) { |
| this.nonDfsUsed = nonDfsUsed; |
| return this; |
| } |
| |
| public DatanodeInfoBuilder setLastBlockReportTime(long time) { |
| this.lastBlockReportTime = time; |
| return this; |
| } |
| |
| public DatanodeInfoBuilder setLastBlockReportMonotonic(long time) { |
| this.lastBlockReportMonotonic = time; |
| return this; |
| } |
| |
| public DatanodeInfo build() { |
| return new DatanodeInfo(ipAddr, hostName, datanodeUuid, xferPort, |
| infoPort, infoSecurePort, ipcPort, capacity, dfsUsed, nonDfsUsed, |
| remaining, blockPoolUsed, cacheCapacity, cacheUsed, lastUpdate, |
| lastUpdateMonotonic, xceiverCount, location, adminState, |
| upgradeDomain, lastBlockReportTime, lastBlockReportMonotonic); |
| } |
| } |
| } |