Example usage for org.apache.hadoop.hdfs.protocol Block equals

Introduction

In this page you can find the example usage for org.apache.hadoop.hdfs.protocol Block equals.

Prototype

@Override 
    public boolean equals(Object o) 

Source Link

Usage

From source file:common.DataNode.java

License:Apache License

/** Block synchronization */
void syncBlock(RecoveringBlock rBlock, List<BlockRecord> syncList) throws IOException {
    Block block = rBlock.getBlock();//ww w  .j  a va  2  s  . c o  m
    long recoveryId = rBlock.getNewGenerationStamp();
    if (LOG.isDebugEnabled()) {
        LOG.debug("block=" + block + ", (length=" + block.getNumBytes() + "), syncList=" + syncList);
    }

    // syncList.isEmpty() means that all data-nodes do not have the block
    // or their replicas have 0 length.
    // The block can be deleted.
    if (syncList.isEmpty()) {
        namenode.commitBlockSynchronization(block, recoveryId, 0, true, true, DatanodeID.EMPTY_ARRAY);
        return;
    }

    // Calculate the best available replica state.
    ReplicaState bestState = ReplicaState.RWR;
    long finalizedLength = -1;
    for (BlockRecord r : syncList) {
        assert r.rInfo.getNumBytes() > 0 : "zero length replica";
        ReplicaState rState = r.rInfo.getOriginalReplicaState();
        if (rState.getValue() < bestState.getValue())
            bestState = rState;
        if (rState == ReplicaState.FINALIZED) {
            if (finalizedLength > 0 && finalizedLength != r.rInfo.getNumBytes())
                throw new IOException("Inconsistent size of finalized replicas. " + "Replica " + r.rInfo
                        + " expected size: " + finalizedLength);
            finalizedLength = r.rInfo.getNumBytes();
        }
    }

    // Calculate list of nodes that will participate in the recovery
    // and the new block size
    List<BlockRecord> participatingList = new ArrayList<BlockRecord>();
    Block newBlock = new Block(block.getBlockId(), -1, recoveryId);
    switch (bestState) {
    case FINALIZED:
        assert finalizedLength > 0 : "finalizedLength is not positive";
        for (BlockRecord r : syncList) {
            ReplicaState rState = r.rInfo.getOriginalReplicaState();
            if (rState == ReplicaState.FINALIZED
                    || rState == ReplicaState.RBW && r.rInfo.getNumBytes() == finalizedLength)
                participatingList.add(r);
        }
        newBlock.setNumBytes(finalizedLength);
        break;
    case RBW:
    case RWR:
        long minLength = Long.MAX_VALUE;
        for (BlockRecord r : syncList) {
            ReplicaState rState = r.rInfo.getOriginalReplicaState();
            if (rState == bestState) {
                minLength = Math.min(minLength, r.rInfo.getNumBytes());
                participatingList.add(r);
            }
        }
        newBlock.setNumBytes(minLength);
        break;
    case RUR:
    case TEMPORARY:
        assert false : "bad replica state: " + bestState;
    }

    List<DatanodeID> failedList = new ArrayList<DatanodeID>();
    List<DatanodeID> successList = new ArrayList<DatanodeID>();
    for (BlockRecord r : participatingList) {
        try {
            Block reply = r.datanode.updateReplicaUnderRecovery(r.rInfo, recoveryId, newBlock.getNumBytes());
            assert reply.equals(newBlock) && reply.getNumBytes() == newBlock
                    .getNumBytes() : "Updated replica must be the same as the new block.";
            successList.add(r.id);
        } catch (IOException e) {
            InterDatanodeProtocol.LOG
                    .warn("Failed to updateBlock (newblock=" + newBlock + ", datanode=" + r.id + ")", e);
            failedList.add(r.id);
        }
    }

    // If any of the data-nodes failed, the recovery fails, because
    // we never know the actual state of the replica on failed data-nodes.
    // The recovery should be started over.
    if (!failedList.isEmpty()) {
        StringBuilder b = new StringBuilder();
        for (DatanodeID id : failedList) {
            b.append("\n  " + id);
        }
        throw new IOException("Cannot recover " + block + ", the following " + failedList.size()
                + " data-nodes failed {" + b + "\n}");
    }

    // Notify the name-node about successfully recovered replicas.
    DatanodeID[] nlist = successList.toArray(new DatanodeID[successList.size()]);
    namenode.commitBlockSynchronization(block, newBlock.getGenerationStamp(), newBlock.getNumBytes(), true,
            false, nlist);
}

---