org.apache.hadoop.hdfs.server.protocol.DisallowedDatanodeException Java Examples

The following examples show how to use org.apache.hadoop.hdfs.server.protocol.DisallowedDatanodeException. You can vote up the ones you like or vote down the ones you don't like, and go to the original project or source file by following the links above each example. You may check out the related API usage on the sidebar.
Example #1
Source File: AvatarDataNode.java    From RDFS with Apache License 2.0 5 votes vote down vote up
void handleRegistrationError(RemoteException re) {
  // If either the primary or standby NN throws these exceptions, this
  // datanode will exit. I think this is the right behaviour because
  // the excludes list on both namenode better be the same.
  String reClass = re.getClassName(); 
  if (UnregisteredDatanodeException.class.getName().equals(reClass) ||
      DisallowedDatanodeException.class.getName().equals(reClass) ||
      IncorrectVersionException.class.getName().equals(reClass)) {
    LOG.warn("DataNode is shutting down: ", re);
    shutdownDN();
  } else {
    LOG.warn(re);
  }
}
 
Example #2
Source File: FSNamesystem.java    From hadoop-gpu with Apache License 2.0 4 votes vote down vote up
/**
 * The given node has reported in.  This method should:
 * 1) Record the heartbeat, so the datanode isn't timed out
 * 2) Adjust usage stats for future block allocation
 * 
 * If a substantial amount of time passed since the last datanode 
 * heartbeat then request an immediate block report.  
 * 
 * @return an array of datanode commands 
 * @throws IOException
 */
DatanodeCommand[] handleHeartbeat(DatanodeRegistration nodeReg,
    long capacity, long dfsUsed, long remaining,
    int xceiverCount, int xmitsInProgress) throws IOException {
  DatanodeCommand cmd = null;
  synchronized (heartbeats) {
    synchronized (datanodeMap) {
      DatanodeDescriptor nodeinfo = null;
      try {
        nodeinfo = getDatanode(nodeReg);
      } catch(UnregisteredDatanodeException e) {
        return new DatanodeCommand[]{DatanodeCommand.REGISTER};
      }
        
      // Check if this datanode should actually be shutdown instead. 
      if (nodeinfo != null && shouldNodeShutdown(nodeinfo)) {
        setDatanodeDead(nodeinfo);
        throw new DisallowedDatanodeException(nodeinfo);
      }

      if (nodeinfo == null || !nodeinfo.isAlive) {
        return new DatanodeCommand[]{DatanodeCommand.REGISTER};
      }

      updateStats(nodeinfo, false);
      nodeinfo.updateHeartbeat(capacity, dfsUsed, remaining, xceiverCount);
      updateStats(nodeinfo, true);
      
      //check lease recovery
      cmd = nodeinfo.getLeaseRecoveryCommand(Integer.MAX_VALUE);
      if (cmd != null) {
        return new DatanodeCommand[] {cmd};
      }
    
      ArrayList<DatanodeCommand> cmds = new ArrayList<DatanodeCommand>(2);
      //check pending replication
      cmd = nodeinfo.getReplicationCommand(
            maxReplicationStreams - xmitsInProgress);
      if (cmd != null) {
        cmds.add(cmd);
      }
      //check block invalidation
      cmd = nodeinfo.getInvalidateBlocks(blockInvalidateLimit);
      if (cmd != null) {
        cmds.add(cmd);
      }
      if (!cmds.isEmpty()) {
        return cmds.toArray(new DatanodeCommand[cmds.size()]);
      }
    }
  }

  //check distributed upgrade
  cmd = getDistributedUpgradeCommand();
  if (cmd != null) {
    return new DatanodeCommand[] {cmd};
  }
  return null;
}
 
Example #3
Source File: FSNamesystem.java    From hadoop-gpu with Apache License 2.0 4 votes vote down vote up
/**
 * The given node is reporting that it received a certain block.
 */
public synchronized void blockReceived(DatanodeID nodeID,  
                                       Block block,
                                       String delHint
                                       ) throws IOException {
  DatanodeDescriptor node = getDatanode(nodeID);
  if (node == null) {
    NameNode.stateChangeLog.warn("BLOCK* NameSystem.blockReceived: "
                                 + block + " is received from an unrecorded node " 
                                 + nodeID.getName());
    throw new IllegalArgumentException(
                                       "Unexpected exception.  Got blockReceived message from node " 
                                       + block + ", but there is no info for it");
  }
      
  if (NameNode.stateChangeLog.isDebugEnabled()) {
    NameNode.stateChangeLog.debug("BLOCK* NameSystem.blockReceived: "
                                  +block+" is received from " + nodeID.getName());
  }

  // Check if this datanode should actually be shutdown instead.
  if (shouldNodeShutdown(node)) {
    setDatanodeDead(node);
    throw new DisallowedDatanodeException(node);
  }

  // decrement number of blocks scheduled to this datanode.
  node.decBlocksScheduled();
  
  // get the deletion hint node
  DatanodeDescriptor delHintNode = null;
  if(delHint!=null && delHint.length()!=0) {
    delHintNode = datanodeMap.get(delHint);
    if(delHintNode == null) {
      NameNode.stateChangeLog.warn("BLOCK* NameSystem.blockReceived: "
          + block
          + " is expected to be removed from an unrecorded node " 
          + delHint);
    }
  }

  //
  // Modify the blocks->datanode map and node's map.
  // 
  pendingReplications.remove(block);
  addStoredBlock(block, node, delHintNode );
}