Java 类org.apache.hadoop.hdfs.protocol.BlockListAsLongs.BlockReportIterator 实例源码

/**
 * processFirstBlockReport is intended only for processing "initial" block
 * reports, the first block report received from a DN after it registers.
 * It just adds all the valid replicas to the datanode, without calculating 
 * a toRemove list (since there won't be any).  It also silently discards 
 * any invalid blocks, thereby deferring their processing until 
 * the next block report.
 * @param storageInfo - DatanodeStorageInfo that sent the report
 * @param report - the initial block report, to be processed
 * @throws IOException 
 */
private void processFirstBlockReport(
    final DatanodeStorageInfo storageInfo,
    final BlockListAsLongs report) throws IOException {
  if (report == null) return;
  assert (namesystem.hasWriteLock());
  assert (storageInfo.getBlockReportCount() == 0);
  BlockReportIterator itBR = report.getBlockReportIterator();

  while(itBR.hasNext()) {
    Block iblk = itBR.next();
    ReplicaState reportedState = itBR.getCurrentReplicaState();

    if (LOG.isDebugEnabled()) {
      LOG.debug("Initial report of block " + iblk.getBlockName()
          + " on " + storageInfo.getDatanodeDescriptor() + " size " +
          iblk.getNumBytes() + " replicaState = " + reportedState);
    }
    if (shouldPostponeBlocksFromFuture &&
        namesystem.isGenStampInFuture(iblk)) {
      queueReportedBlock(storageInfo, iblk, reportedState,
          QUEUE_REASON_FUTURE_GENSTAMP);
      continue;
    }

    BlockInfo storedBlock = blocksMap.getStoredBlock(iblk);
    // If block does not belong to any file, we are done.
    if (storedBlock == null) continue;

    // If block is corrupt, mark it and continue to next block.
    BlockUCState ucState = storedBlock.getBlockUCState();
    BlockToMarkCorrupt c = checkReplicaCorrupt(
        iblk, reportedState, storedBlock, ucState,
        storageInfo.getDatanodeDescriptor());
    if (c != null) {
      if (shouldPostponeBlocksFromFuture) {
        // In the Standby, we may receive a block report for a file that we
        // just have an out-of-date gen-stamp or state for, for example.
        queueReportedBlock(storageInfo, iblk, reportedState,
            QUEUE_REASON_CORRUPT_STATE);
      } else {
        markBlockAsCorrupt(c, storageInfo, storageInfo.getDatanodeDescriptor());
      }
      continue;
    }

    // If block is under construction, add this replica to its list
    if (isBlockUnderConstruction(storedBlock, ucState, reportedState)) {
      ((BlockInfoUnderConstruction)storedBlock).addReplicaIfNotPresent(
          storageInfo, iblk, reportedState);
      // OpenFileBlocks only inside snapshots also will be added to safemode
      // threshold. So we need to update such blocks to safemode
      // refer HDFS-5283
      BlockInfoUnderConstruction blockUC = (BlockInfoUnderConstruction) storedBlock;
      if (namesystem.isInSnapshot(blockUC)) {
        int numOfReplicas = blockUC.getNumExpectedLocations();
        namesystem.incrementSafeBlockCount(numOfReplicas);
      }
      //and fall through to next clause
    }      
    //add replica if appropriate
    if (reportedState == ReplicaState.FINALIZED) {
      addStoredBlockImmediate(storedBlock, storageInfo);
    }
  }
}

/**
 * processFirstBlockReport is intended only for processing "initial" block
 * reports, the first block report received from a DN after it registers.
 * It just adds all the valid replicas to the datanode, without calculating 
 * a toRemove list (since there won't be any).  It also silently discards 
 * any invalid blocks, thereby deferring their processing until 
 * the next block report.
 * @param node - DatanodeDescriptor of the node that sent the report
 * @param report - the initial block report, to be processed
 * @throws IOException 
 */
private void processFirstBlockReport(final DatanodeDescriptor node,
    final BlockListAsLongs report) throws IOException {
  if (report == null) return;
  assert (namesystem.hasWriteLock());
  assert (node.numBlocks() == 0);
  BlockReportIterator itBR = report.getBlockReportIterator();

  while(itBR.hasNext()) {
    Block iblk = itBR.next();
    ReplicaState reportedState = itBR.getCurrentReplicaState();

    if (shouldPostponeBlocksFromFuture &&
        namesystem.isGenStampInFuture(iblk)) {
      queueReportedBlock(node, iblk, reportedState,
          QUEUE_REASON_FUTURE_GENSTAMP);
      continue;
    }

    BlockInfo storedBlock = blocksMap.getStoredBlock(iblk);
    // If block does not belong to any file, we are done.
    if (storedBlock == null) continue;

    // If block is corrupt, mark it and continue to next block.
    BlockUCState ucState = storedBlock.getBlockUCState();
    BlockToMarkCorrupt c = checkReplicaCorrupt(
        iblk, reportedState, storedBlock, ucState, node);
    if (c != null) {
      if (shouldPostponeBlocksFromFuture) {
        // In the Standby, we may receive a block report for a file that we
        // just have an out-of-date gen-stamp or state for, for example.
        queueReportedBlock(node, iblk, reportedState,
            QUEUE_REASON_CORRUPT_STATE);
      } else {
        markBlockAsCorrupt(c, node);
      }
      continue;
    }

    // If block is under construction, add this replica to its list
    if (isBlockUnderConstruction(storedBlock, ucState, reportedState)) {
      ((BlockInfoUnderConstruction)storedBlock).addReplicaIfNotPresent(
          node, iblk, reportedState);
      //and fall through to next clause
    }      
    //add replica if appropriate
    if (reportedState == ReplicaState.FINALIZED) {
      addStoredBlockImmediate(storedBlock, node);
    }
  }
}

/**
 * processFirstBlockReport is intended only for processing "initial" block
 * reports, the first block report received from a DN after it registers.
 * It just adds all the valid replicas to the datanode, without calculating 
 * a toRemove list (since there won't be any).  It also silently discards 
 * any invalid blocks, thereby deferring their processing until 
 * the next block report.
 * @param storageInfo - DatanodeStorageInfo that sent the report
 * @param report - the initial block report, to be processed
 * @throws IOException 
 */
private void processFirstBlockReport(
    final DatanodeStorageInfo storageInfo,
    final BlockListAsLongs report) throws IOException {
  if (report == null) return;
  assert (namesystem.hasWriteLock());
  assert (storageInfo.numBlocks() == 0);
  BlockReportIterator itBR = report.getBlockReportIterator();

  while(itBR.hasNext()) {
    Block iblk = itBR.next();
    ReplicaState reportedState = itBR.getCurrentReplicaState();

    if (shouldPostponeBlocksFromFuture &&
        namesystem.isGenStampInFuture(iblk)) {
      queueReportedBlock(storageInfo, iblk, reportedState,
          QUEUE_REASON_FUTURE_GENSTAMP);
      continue;
    }

    BlockInfo storedBlock = blocksMap.getStoredBlock(iblk);
    // If block does not belong to any file, we are done.
    if (storedBlock == null) continue;

    // If block is corrupt, mark it and continue to next block.
    BlockUCState ucState = storedBlock.getBlockUCState();
    BlockToMarkCorrupt c = checkReplicaCorrupt(
        iblk, reportedState, storedBlock, ucState,
        storageInfo.getDatanodeDescriptor());
    if (c != null) {
      if (shouldPostponeBlocksFromFuture) {
        // In the Standby, we may receive a block report for a file that we
        // just have an out-of-date gen-stamp or state for, for example.
        queueReportedBlock(storageInfo, iblk, reportedState,
            QUEUE_REASON_CORRUPT_STATE);
      } else {
        markBlockAsCorrupt(c, storageInfo, storageInfo.getDatanodeDescriptor());
      }
      continue;
    }

    // If block is under construction, add this replica to its list
    if (isBlockUnderConstruction(storedBlock, ucState, reportedState)) {
      ((BlockInfoUnderConstruction)storedBlock).addReplicaIfNotPresent(
          storageInfo, iblk, reportedState);
      // OpenFileBlocks only inside snapshots also will be added to safemode
      // threshold. So we need to update such blocks to safemode
      // refer HDFS-5283
      BlockInfoUnderConstruction blockUC = (BlockInfoUnderConstruction) storedBlock;
      if (namesystem.isInSnapshot(blockUC)) {
        int numOfReplicas = blockUC.getNumExpectedLocations();
        namesystem.incrementSafeBlockCount(numOfReplicas);
      }
      //and fall through to next clause
    }      
    //add replica if appropriate
    if (reportedState == ReplicaState.FINALIZED) {
      addStoredBlockImmediate(storedBlock, storageInfo);
    }
  }
}

/**
 * processFirstBlockReport is intended only for processing "initial" block
 * reports, the first block report received from a DN after it registers.
 * It just adds all the valid replicas to the datanode, without calculating 
 * a toRemove list (since there won't be any).  It also silently discards 
 * any invalid blocks, thereby deferring their processing until 
 * the next block report.
 * @param node - DatanodeDescriptor of the node that sent the report
 * @param report - the initial block report, to be processed
 * @throws IOException 
 */
private void processFirstBlockReport(final DatanodeDescriptor node,
    final BlockListAsLongs report) throws IOException {
  if (report == null) return;
  assert (namesystem.hasWriteLock());
  assert (node.numBlocks() == 0);
  BlockReportIterator itBR = report.getBlockReportIterator();

  while(itBR.hasNext()) {
    Block iblk = itBR.next();
    ReplicaState reportedState = itBR.getCurrentReplicaState();

    if (shouldPostponeBlocksFromFuture &&
        namesystem.isGenStampInFuture(iblk)) {
      queueReportedBlock(node, iblk, reportedState,
          QUEUE_REASON_FUTURE_GENSTAMP);
      continue;
    }

    BlockInfo storedBlock = blocksMap.getStoredBlock(iblk);
    // If block does not belong to any file, we are done.
    if (storedBlock == null) continue;

    // If block is corrupt, mark it and continue to next block.
    BlockUCState ucState = storedBlock.getBlockUCState();
    BlockToMarkCorrupt c = checkReplicaCorrupt(
        iblk, reportedState, storedBlock, ucState, node);
    if (c != null) {
      if (shouldPostponeBlocksFromFuture) {
        // In the Standby, we may receive a block report for a file that we
        // just have an out-of-date gen-stamp or state for, for example.
        queueReportedBlock(node, iblk, reportedState,
            QUEUE_REASON_CORRUPT_STATE);
      } else {
        markBlockAsCorrupt(c, node);
      }
      continue;
    }

    // If block is under construction, add this replica to its list
    if (isBlockUnderConstruction(storedBlock, ucState, reportedState)) {
      ((BlockInfoUnderConstruction)storedBlock).addReplicaIfNotPresent(
          node, iblk, reportedState);
      //and fall through to next clause
    }      
    //add replica if appropriate
    if (reportedState == ReplicaState.FINALIZED) {
      addStoredBlockImmediate(storedBlock, node);
    }
  }
}

/**
 * processFirstBlockReport is intended only for processing "initial" block
 * reports, the first block report received from a DN after it registers.
 * It just adds all the valid replicas to the datanode, without calculating 
 * a toRemove list (since there won't be any).  It also silently discards 
 * any invalid blocks, thereby deferring their processing until 
 * the next block report.
 * @param node - DatanodeDescriptor of the node that sent the report
 * @param report - the initial block report, to be processed
 * @throws IOException 
 */
private void processFirstBlockReport(final DatanodeDescriptor node,
    final BlockListAsLongs report) throws IOException {
  if (report == null) return;
  assert (namesystem.hasWriteLock());
  assert (node.numBlocks() == 0);
  BlockReportIterator itBR = report.getBlockReportIterator();

  while(itBR.hasNext()) {
    Block iblk = itBR.next();
    ReplicaState reportedState = itBR.getCurrentReplicaState();

    if (shouldPostponeBlocksFromFuture &&
        namesystem.isGenStampInFuture(iblk)) {
      queueReportedBlock(node, iblk, reportedState,
          QUEUE_REASON_FUTURE_GENSTAMP);
      continue;
    }

    BlockInfo storedBlock = blocksMap.getStoredBlock(iblk);
    // If block does not belong to any file, we are done.
    if (storedBlock == null) continue;

    // If block is corrupt, mark it and continue to next block.
    BlockUCState ucState = storedBlock.getBlockUCState();
    BlockToMarkCorrupt c = checkReplicaCorrupt(
        iblk, reportedState, storedBlock, ucState, node);
    if (c != null) {
      if (shouldPostponeBlocksFromFuture) {
        // In the Standby, we may receive a block report for a file that we
        // just have an out-of-date gen-stamp or state for, for example.
        queueReportedBlock(node, iblk, reportedState,
            QUEUE_REASON_CORRUPT_STATE);
      } else {
        markBlockAsCorrupt(c, node);
      }
      continue;
    }

    // If block is under construction, add this replica to its list
    if (isBlockUnderConstruction(storedBlock, ucState, reportedState)) {
      ((BlockInfoUnderConstruction)storedBlock).addReplicaIfNotPresent(
          node, iblk, reportedState);
      //and fall through to next clause
    }      
    //add replica if appropriate
    if (reportedState == ReplicaState.FINALIZED) {
      addStoredBlockImmediate(storedBlock, node);
    }
  }
}

/**
 * processFirstBlockReport is intended only for processing "initial" block
 * reports, the first block report received from a DN after it registers.
 * It just adds all the valid replicas to the datanode, without calculating 
 * a toRemove list (since there won't be any).  It also silently discards 
 * any invalid blocks, thereby deferring their processing until 
 * the next block report.
 * @param node - DatanodeDescriptor of the node that sent the report
 * @param report - the initial block report, to be processed
 * @throws IOException 
 */
private void processFirstBlockReport(final DatanodeDescriptor node,
    final String storageID,
    final BlockListAsLongs report) throws IOException {
  if (report == null) return;
  assert (namesystem.hasWriteLock());
  assert (node.getStorageInfo(storageID).numBlocks() == 0);
  BlockReportIterator itBR = report.getBlockReportIterator();

  while(itBR.hasNext()) {
    Block iblk = itBR.next();
    ReplicaState reportedState = itBR.getCurrentReplicaState();

    if (shouldPostponeBlocksFromFuture &&
        namesystem.isGenStampInFuture(iblk)) {
      queueReportedBlock(node, storageID, iblk, reportedState,
          QUEUE_REASON_FUTURE_GENSTAMP);
      continue;
    }

    BlockInfo storedBlock = blocksMap.getStoredBlock(iblk);
    // If block does not belong to any file, we are done.
    if (storedBlock == null) continue;

    // If block is corrupt, mark it and continue to next block.
    BlockUCState ucState = storedBlock.getBlockUCState();
    BlockToMarkCorrupt c = checkReplicaCorrupt(
        iblk, reportedState, storedBlock, ucState, node);
    if (c != null) {
      if (shouldPostponeBlocksFromFuture) {
        // In the Standby, we may receive a block report for a file that we
        // just have an out-of-date gen-stamp or state for, for example.
        queueReportedBlock(node, storageID, iblk, reportedState,
            QUEUE_REASON_CORRUPT_STATE);
      } else {
        markBlockAsCorrupt(c, node, storageID);
      }
      continue;
    }

    // If block is under construction, add this replica to its list
    if (isBlockUnderConstruction(storedBlock, ucState, reportedState)) {
      ((BlockInfoUnderConstruction)storedBlock).addReplicaIfNotPresent(
          node.getStorageInfo(storageID), iblk, reportedState);
      // OpenFileBlocks only inside snapshots also will be added to safemode
      // threshold. So we need to update such blocks to safemode
      // refer HDFS-5283
      BlockInfoUnderConstruction blockUC = (BlockInfoUnderConstruction) storedBlock;
      if (namesystem.isInSnapshot(blockUC)) {
        int numOfReplicas = blockUC.getNumExpectedLocations();
        namesystem.incrementSafeBlockCount(numOfReplicas);
      }
      //and fall through to next clause
    }      
    //add replica if appropriate
    if (reportedState == ReplicaState.FINALIZED) {
      addStoredBlockImmediate(storedBlock, node, storageID);
    }
  }
}