Java BlockUCState.COMMITTED属性代码示例

/**
 * Faster version of {@link #addStoredBlock},
 * intended for use with initial block report at startup. If not in startup
 * safe mode, will call standard addStoredBlock(). Assumes this method is
 * called "immediately" so there is no need to refresh the storedBlock from
 * blocksMap. Doesn't handle underReplication/overReplication, or worry about
 * pendingReplications or corruptReplicas, because it's in startup safe mode.
 * Doesn't log every block, because there are typically millions of them.
 * 
 * @throws IOException
 */
private void addStoredBlockImmediate(BlockInfoContiguous storedBlock,
    DatanodeStorageInfo storageInfo)
throws IOException {
  assert (storedBlock != null && namesystem.hasWriteLock());
  if (!namesystem.isInStartupSafeMode() 
      || namesystem.isPopulatingReplQueues()) {
    addStoredBlock(storedBlock, storageInfo, null, false);
    return;
  }

  // just add it
  AddBlockResult result = storageInfo.addBlock(storedBlock);

  // Now check for completion of blocks and safe block count
  int numCurrentReplica = countLiveNodes(storedBlock);
  if (storedBlock.getBlockUCState() == BlockUCState.COMMITTED
      && numCurrentReplica >= minReplication) {
    completeBlock(storedBlock.getBlockCollection(), storedBlock, false);
  } else if (storedBlock.isComplete() && result == AddBlockResult.ADDED) {
    // check whether safe replication is reached for the block
    // only complete blocks are counted towards that.
    // In the case that the block just became complete above, completeBlock()
    // handles the safe block count maintenance.
    namesystem.incrementSafeBlockCount(numCurrentReplica);
  }
}
 

/**
 * Commit block's length and generation stamp as reported by the client.
 * Set block state to {@link BlockUCState#COMMITTED}.
 * @param block - contains client reported block length and generation 
 * @throws IOException if block ids are inconsistent.
 */
void commitBlock(Block block) throws IOException {
  if(getBlockId() != block.getBlockId())
    throw new IOException("Trying to commit inconsistent block: id = "
        + block.getBlockId() + ", expected id = " + getBlockId());
  blockUCState = BlockUCState.COMMITTED;
  this.set(getBlockId(), block.getNumBytes(), block.getGenerationStamp());
  // Sort out invalid replicas.
  setGenerationStampAndVerifyReplicas(block.getGenerationStamp());
}
 

/**
 * Convert a specified block of the file to a complete block.
 * @throws IOException if the block does not have at least a minimal number
 * of replicas reported from data-nodes.
 */
private void completeBlock(BlockInfo curBlock, boolean force)
    throws IOException {
  if (curBlock.isComplete()) {
    return;
  }

  int numNodes = curBlock.numNodes();
  if (!force && !hasMinStorage(curBlock, numNodes)) {
    throw new IOException("Cannot complete block: "
        + "block does not satisfy minimal replication requirement.");
  }
  if (!force && curBlock.getBlockUCState() != BlockUCState.COMMITTED) {
    throw new IOException(
        "Cannot complete block: block has not been COMMITTED by the client");
  }

  curBlock.convertToCompleteBlock();
  // Since safe-mode only counts complete blocks, and we now have
  // one more complete block, we need to adjust the total up, and
  // also count it as safe, if we have at least the minimum replica
  // count. (We may not have the minimum replica count yet if this is
  // a "forced" completion when a file is getting closed by an
  // OP_CLOSE edit on the standby).
  bmSafeMode.adjustBlockTotals(0, 1);
  final int minStorage = curBlock.isStriped() ?
      ((BlockInfoStriped) curBlock).getRealDataBlockNum() : minReplication;
  bmSafeMode.incrementSafeBlockCount(Math.min(numNodes, minStorage),
      curBlock);
}
 

/**
 * Faster version of {@link #addStoredBlock},
 * intended for use with initial block report at startup. If not in startup
 * safe mode, will call standard addStoredBlock(). Assumes this method is
 * called "immediately" so there is no need to refresh the storedBlock from
 * blocksMap. Doesn't handle underReplication/overReplication, or worry about
 * pendingReplications or corruptReplicas, because it's in startup safe mode.
 * Doesn't log every block, because there are typically millions of them.
 * 
 * @throws IOException
 */
private void addStoredBlockImmediate(BlockInfo storedBlock, Block reported,
    DatanodeStorageInfo storageInfo)
throws IOException {
  assert (storedBlock != null && namesystem.hasWriteLock());
  if (!namesystem.isInStartupSafeMode()
      || isPopulatingReplQueues()) {
    addStoredBlock(storedBlock, reported, storageInfo, null, false);
    return;
  }

  // just add it
  AddBlockResult result = storageInfo.addBlock(storedBlock, reported);

  // Now check for completion of blocks and safe block count
  int numCurrentReplica = countLiveNodes(storedBlock);
  if (storedBlock.getBlockUCState() == BlockUCState.COMMITTED
      && hasMinStorage(storedBlock, numCurrentReplica)) {
    completeBlock(storedBlock, false);
  } else if (storedBlock.isComplete() && result == AddBlockResult.ADDED) {
    // check whether safe replication is reached for the block
    // only complete blocks are counted towards that.
    // In the case that the block just became complete above, completeBlock()
    // handles the safe block count maintenance.
    bmSafeMode.incrementSafeBlockCount(numCurrentReplica, storedBlock);
  }
}
 

/**
 * If the block is committed/completed and its length is less than a full
 * stripe, it returns the the number of actual data blocks.
 * Otherwise it returns the number of data units specified by erasure coding policy.
 */
public short getRealDataBlockNum() {
  if (isComplete() || getBlockUCState() == BlockUCState.COMMITTED) {
    return (short) Math.min(getDataBlockNum(),
        (getNumBytes() - 1) / ecPolicy.getCellSize() + 1);
  } else {
    return getDataBlockNum();
  }
}
 

/**
 * Faster version of
 * {@link #addStoredBlock(BlockInfo, DatanodeStorageInfo, DatanodeDescriptor, boolean)}
 * , intended for use with initial block report at startup. If not in startup
 * safe mode, will call standard addStoredBlock(). Assumes this method is
 * called "immediately" so there is no need to refresh the storedBlock from
 * blocksMap. Doesn't handle underReplication/overReplication, or worry about
 * pendingReplications or corruptReplicas, because it's in startup safe mode.
 * Doesn't log every block, because there are typically millions of them.
 * 
 * @throws IOException
 */
private void addStoredBlockImmediate(BlockInfo storedBlock,
    DatanodeStorageInfo storageInfo)
throws IOException {
  assert (storedBlock != null && namesystem.hasWriteLock());
  if (!namesystem.isInStartupSafeMode() 
      || namesystem.isPopulatingReplQueues()) {
    addStoredBlock(storedBlock, storageInfo, null, false);
    return;
  }

  // just add it
  AddBlockResult result = storageInfo.addBlock(storedBlock);

  // Now check for completion of blocks and safe block count
  int numCurrentReplica = countLiveNodes(storedBlock);
  if (storedBlock.getBlockUCState() == BlockUCState.COMMITTED
      && numCurrentReplica >= minReplication) {
    completeBlock(storedBlock.getBlockCollection(), storedBlock, false);
  } else if (storedBlock.isComplete() && result == AddBlockResult.ADDED) {
    // check whether safe replication is reached for the block
    // only complete blocks are counted towards that.
    // In the case that the block just became complete above, completeBlock()
    // handles the safe block count maintenance.
    namesystem.incrementSafeBlockCount(numCurrentReplica);
  }
}
 

/**
 * Faster version of
 * {@link #addStoredBlock(BlockInfo, DatanodeDescriptor, DatanodeDescriptor, boolean)}
 * , intended for use with initial block report at startup. If not in startup
 * safe mode, will call standard addStoredBlock(). Assumes this method is
 * called "immediately" so there is no need to refresh the storedBlock from
 * blocksMap. Doesn't handle underReplication/overReplication, or worry about
 * pendingReplications or corruptReplicas, because it's in startup safe mode.
 * Doesn't log every block, because there are typically millions of them.
 * 
 * @throws IOException
 */
private void addStoredBlockImmediate(BlockInfo storedBlock,
                             DatanodeDescriptor node)
throws IOException {
  assert (storedBlock != null && namesystem.hasWriteLock());
  if (!namesystem.isInStartupSafeMode() 
      || namesystem.isPopulatingReplQueues()) {
    addStoredBlock(storedBlock, node, null, false);
    return;
  }

  // just add it
  node.addBlock(storedBlock);

  // Now check for completion of blocks and safe block count
  int numCurrentReplica = countLiveNodes(storedBlock);
  if (storedBlock.getBlockUCState() == BlockUCState.COMMITTED
      && numCurrentReplica >= minReplication) {
    completeBlock((MutableBlockCollection)storedBlock.getBlockCollection(), storedBlock, false);
  } else if (storedBlock.isComplete()) {
    // check whether safe replication is reached for the block
    // only complete blocks are counted towards that.
    // In the case that the block just became complete above, completeBlock()
    // handles the safe block count maintenance.
    namesystem.incrementSafeBlockCount(numCurrentReplica);
  }
}
 

/**
 * Commit block's length and generation stamp as reported by the client.
 * Set block state to {@link BlockUCState#COMMITTED}.
 * @param block - contains client reported block length and generation 
 * @throws IOException if block ids are inconsistent.
 */
void commitBlock(Block block) throws IOException {
  if(getBlockId() != block.getBlockId())
    throw new IOException("Trying to commit inconsistent block: id = "
        + block.getBlockId() + ", expected id = " + getBlockId());
  blockUCState = BlockUCState.COMMITTED;
  this.set(getBlockId(), block.getNumBytes(), block.getGenerationStamp());
}
 

/**
 * Faster version of
 * {@link #addStoredBlock(BlockInfo, DatanodeStorageInfo, DatanodeDescriptor, boolean)}
 * , intended for use with initial block report at startup. If not in startup
 * safe mode, will call standard addStoredBlock(). Assumes this method is
 * called "immediately" so there is no need to refresh the storedBlock from
 * blocksMap. Doesn't handle underReplication/overReplication, or worry about
 * pendingReplications or corruptReplicas, because it's in startup safe mode.
 * Doesn't log every block, because there are typically millions of them.
 * 
 * @throws IOException
 */
private void addStoredBlockImmediate(BlockInfo storedBlock,
    DatanodeStorageInfo storageInfo)
throws IOException {
  assert (storedBlock != null && namesystem.hasWriteLock());
  if (!namesystem.isInStartupSafeMode() 
      || namesystem.isPopulatingReplQueues()) {
    addStoredBlock(storedBlock, storageInfo, null, false);
    return;
  }

  // just add it
  storageInfo.addBlock(storedBlock);

  // Now check for completion of blocks and safe block count
  int numCurrentReplica = countLiveNodes(storedBlock);
  if (storedBlock.getBlockUCState() == BlockUCState.COMMITTED
      && numCurrentReplica >= minReplication) {
    completeBlock(storedBlock.getBlockCollection(), storedBlock, false);
  } else if (storedBlock.isComplete()) {
    // check whether safe replication is reached for the block
    // only complete blocks are counted towards that.
    // In the case that the block just became complete above, completeBlock()
    // handles the safe block count maintenance.
    namesystem.incrementSafeBlockCount(numCurrentReplica);
  }
}
 

/**
 * Faster version of
 * {@link #addStoredBlock(BlockInfo, DatanodeDescriptor, DatanodeDescriptor,
 * boolean)}
 * , intended for use with initial block report at startup. If not in startup
 * safe mode, will call standard addStoredBlock(). Assumes this method is
 * called "immediately" so there is no need to refresh the storedBlock from
 * blocksMap. Doesn't handle underReplication/overReplication, or worry about
 * pendingReplications or corruptReplicas, because it's in startup safe mode.
 * Doesn't log every block, because there are typically millions of them.
 *
 * @throws IOException
 */
private void addStoredBlockImmediate(BlockInfo storedBlock,
    DatanodeDescriptor node) throws IOException {
  assert (storedBlock != null);
  if (!namesystem.isInStartupSafeMode() ||
      namesystem.isPopulatingReplQueues()) {
    addStoredBlock(storedBlock, node, null, false);
    return;
  }

  // just add it
  node.addBlock(storedBlock);

  // Now check for completion of blocks and safe block count
  int numCurrentReplica = countLiveNodes(storedBlock);
  if (storedBlock.getBlockUCState() == BlockUCState.COMMITTED &&
      numCurrentReplica >= minReplication) {
    completeBlock((MutableBlockCollection) storedBlock.getBlockCollection(),
        storedBlock, false);
  } else if (storedBlock.isComplete()) {
    // check whether safe replication is reached for the block
    // only complete blocks are counted towards that.
    // In the case that the block just became complete above, completeBlock()
    // handles the safe block count maintenance.
    namesystem.incrementSafeBlockCount(storedBlock);
  }
}
 

public BlockInfo tryToCompleteBlock(final MutableBlockCollection bc,
    final int blkIndex) throws IOException {

  if (blkIndex < 0) {
    return null;
  }
  BlockInfo curBlock = bc.getBlock(blkIndex);
  LOG.debug("tryToCompleteBlock. blkId = " + curBlock.getBlockId());
  if (curBlock.isComplete()) {
    return curBlock;
  }
  BlockInfoUnderConstruction ucBlock = (BlockInfoUnderConstruction) curBlock;
  int numNodes = ucBlock.numNodes(datanodeManager);
  if (numNodes < minReplication) {
    return null;
  }
  if (ucBlock.getBlockUCState() != BlockUCState.COMMITTED) {
    return null;
  }
  BlockInfo completeBlock = ucBlock.convertToCompleteBlock();
  // replace penultimate block in file
  bc.setBlock(blkIndex, completeBlock);

  // Since safe-mode only counts complete blocks, and we now have
  // one more complete block, we need to adjust the total up, and
  // also count it as safe, if we have at least the minimum replica
  // count. (We may not have the minimum replica count yet if this is
  // a "forced" completion when a file is getting closed by an
  // OP_CLOSE edit on the standby).
  namesystem.adjustSafeModeBlockTotals(0, 1);
  namesystem.incrementSafeBlockCount(curBlock);

  return completeBlock;
}
 

/**
 * Commit block's length and generation stamp as reported by the client. Set
 * block state to {@link BlockUCState#COMMITTED}.
 *
 * @param block
 *     - contains client reported block length and generation
 * @throws IOException
 *     if block ids are inconsistent.
 */
void commitBlock(Block block) throws IOException {
  if (getBlockId() != block.getBlockId()) {
    throw new IOException(
        "Trying to commit inconsistent block: id = " + block.getBlockId() +
            ", expected id = " + getBlockId());
  }
  blockUCState = BlockUCState.COMMITTED;
  this.set(getBlockId(), block.getNumBytes(), block.getGenerationStamp());
}
 

/**
 * Faster version of
 * {@link #addStoredBlock(BlockInfo, DatanodeDescriptor, String, DatanodeDescriptor, boolean)}
 * , intended for use with initial block report at startup. If not in startup
 * safe mode, will call standard addStoredBlock(). Assumes this method is
 * called "immediately" so there is no need to refresh the storedBlock from
 * blocksMap. Doesn't handle underReplication/overReplication, or worry about
 * pendingReplications or corruptReplicas, because it's in startup safe mode.
 * Doesn't log every block, because there are typically millions of them.
 * 
 * @throws IOException
 */
private void addStoredBlockImmediate(BlockInfo storedBlock,
    DatanodeDescriptor node, String storageID)
throws IOException {
  assert (storedBlock != null && namesystem.hasWriteLock());
  if (!namesystem.isInStartupSafeMode() 
      || namesystem.isPopulatingReplQueues()) {
    addStoredBlock(storedBlock, node, storageID, null, false);
    return;
  }

  // just add it
  node.addBlock(storageID, storedBlock);

  // Now check for completion of blocks and safe block count
  int numCurrentReplica = countLiveNodes(storedBlock);
  if (storedBlock.getBlockUCState() == BlockUCState.COMMITTED
      && numCurrentReplica >= minReplication) {
    completeBlock(storedBlock.getBlockCollection(), storedBlock, false);
  } else if (storedBlock.isComplete()) {
    // check whether safe replication is reached for the block
    // only complete blocks are counted towards that.
    // In the case that the block just became complete above, completeBlock()
    // handles the safe block count maintenance.
    namesystem.incrementSafeBlockCount(numCurrentReplica);
  }
}
 

/**
 * Set {@link #blockUCState} to {@link BlockUCState#COMMITTED}.
 */
void commit() {
  blockUCState = BlockUCState.COMMITTED;
}