* 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.

*/

* Keeps information related to the blocks stored in the Hadoop cluster.

*/

  static final Log LOG = LogFactory.getLog(BlockManager.class);

  static final Log blockLog = NameNode.blockStateChangeLog;

  /** Default load factor of map */

  public static final float DEFAULT_MAP_LOAD_FACTOR = 0.75f;

  private final Namesystem namesystem;

  private final DatanodeManager datanodeManager;

  private final HeartbeatManager heartbeatManager;

  private final BlockTokenSecretManager blockTokenSecretManager;

  private volatile long pendingReplicationBlocksCount = 0L;

  private volatile long corruptReplicaBlocksCount = 0L;

  private volatile long underReplicatedBlocksCount = 0L;

  private volatile long scheduledReplicationBlocksCount = 0L;

  private volatile long excessBlocksCount = 0L;

 

  /** Used by metrics */

  public long getPendingReplicationBlocksCount() {

    return pendingReplicationBlocksCount;

  }

  /** Used by metrics */

  public long getUnderReplicatedBlocksCount() {

    return underReplicatedBlocksCount;

  }

  /** Used by metrics */

  public long getCorruptReplicaBlocksCount() {

    return corruptReplicaBlocksCount;

  }

  /** Used by metrics */

  public long getScheduledReplicationBlocksCount() {

    return scheduledReplicationBlocksCount;

  }

  /** Used by metrics */

  public long getPendingDeletionBlocksCount() {

    return invalidateBlocks.numBlocks();

  }

  /** Used by metrics */

  public long getExcessBlocksCount() {

    return excessBlocksCount;

  }

  /**replicationRecheckInterval is how often namenode checks for new replication work*/

  private final long replicationRecheckInterval;

 

  /**

   * Mapping: Block -> { INode, datanodes, self ref }

   * Updated only in response to client-sent information.

   */

  final BlocksMap blocksMap;

  /** Replication thread. */

  final Daemon replicationThread = new Daemon(new ReplicationMonitor());

 

  /** Store blocks -> datanodedescriptor(s) map of corrupt replicas */

  final CorruptReplicasMap corruptReplicas = new CorruptReplicasMap();

  /** Blocks to be invalidated. */

  private final InvalidateBlocks invalidateBlocks;

  //

  // Keeps a TreeSet for every named node. Each treeset contains

  // a list of the blocks that are "extra" at that location. We'll

  // eventually remove these extras.

  // Mapping: StorageID -> TreeSet<Block>

  //

  public final Map<String, Collection<Block>> excessReplicateMap =

    new TreeMap<String, Collection<Block>>();

  //

  // Store set of Blocks that need to be replicated 1 or more times.

  // We also store pending replication-orders.

  //

  public final UnderReplicatedBlocks neededReplications = new UnderReplicatedBlocks();

  @VisibleForTesting

  final PendingReplicationBlocks pendingReplications;

  /** The maximum number of replicas allowed for a block */

  public final short maxReplication;

  /**

   * The maximum number of outgoing replication streams a given node should have

   * at one time considering all but the highest priority replications needed.

   */

  int maxReplicationStreams;

  /**

   * The maximum number of outgoing replication streams a given node should have

   * at one time.

   */

  int replicationStreamsHardLimit;

  /** Minimum copies needed or else write is disallowed */

  public final short minReplication;

  /** Default number of replicas */

  public final int defaultReplication;

  /** The maximum number of entries returned by getCorruptInodes() */

  final int maxCorruptFilesReturned;

  /** variable to enable check for enough racks */

  final boolean shouldCheckForEnoughRacks;

  /** Last block index used for replication work. */

  private int replIndex = 0;

  /** for block replicas placement */

  private BlockPlacementPolicy blockplacement;

 

  public BlockManager(final Namesystem namesystem, final FSClusterStats stats,

      final Configuration conf) throws IOException {

    this.namesystem = namesystem;

    datanodeManager = new DatanodeManager(this, namesystem, conf);

    heartbeatManager = datanodeManager.getHeartbeatManager();

    invalidateBlocks = new InvalidateBlocks(datanodeManager);

    blocksMap = new BlocksMap(DEFAULT_MAP_LOAD_FACTOR);

    blockplacement = BlockPlacementPolicy.getInstance(

        conf, stats, datanodeManager.getNetworkTopology());

    pendingReplications = new PendingReplicationBlocks(conf.getInt(

      DFSConfigKeys.DFS_NAMENODE_REPLICATION_PENDING_TIMEOUT_SEC_KEY,

      DFSConfigKeys.DFS_NAMENODE_REPLICATION_PENDING_TIMEOUT_SEC_DEFAULT) * 1000L);

    blockTokenSecretManager = createBlockTokenSecretManager(conf);

    this.maxCorruptFilesReturned = conf.getInt(

      DFSConfigKeys.DFS_DEFAULT_MAX_CORRUPT_FILES_RETURNED_KEY,

      DFSConfigKeys.DFS_DEFAULT_MAX_CORRUPT_FILES_RETURNED);

    this.defaultReplication = conf.getInt(DFSConfigKeys.DFS_REPLICATION_KEY,

                                          DFSConfigKeys.DFS_REPLICATION_DEFAULT);

    final int maxR = conf.getInt(DFSConfigKeys.DFS_REPLICATION_MAX_KEY,

                                 DFSConfigKeys.DFS_REPLICATION_MAX_DEFAULT);

    final int minR = conf.getInt(DFSConfigKeys.DFS_NAMENODE_REPLICATION_MIN_KEY,

                                 DFSConfigKeys.DFS_NAMENODE_REPLICATION_MIN_DEFAULT);

    if (minR <= 0)

      throw new IOException("Unexpected configuration parameters: "

          + DFSConfigKeys.DFS_NAMENODE_REPLICATION_MIN_KEY

          + " = " + minR + " <= 0");

    if (maxR > Short.MAX_VALUE)

      throw new IOException("Unexpected configuration parameters: "

          + DFSConfigKeys.DFS_REPLICATION_MAX_KEY

          + " = " + maxR + " > " + Short.MAX_VALUE);

    if (minR > maxR)

      throw new IOException("Unexpected configuration parameters: "

          + DFSConfigKeys.DFS_NAMENODE_REPLICATION_MIN_KEY

          + " = " + minR + " > "

          + DFSConfigKeys.DFS_REPLICATION_MAX_KEY

          + " = " + maxR);

    this.minReplication = (short)minR;

    this.maxReplication = (short)maxR;

    this.maxReplicationStreams =

        conf.getInt(DFSConfigKeys.DFS_NAMENODE_REPLICATION_MAX_STREAMS_KEY,

            DFSConfigKeys.DFS_NAMENODE_REPLICATION_MAX_STREAMS_DEFAULT);

    this.replicationStreamsHardLimit =

        conf.getInt(

            DFSConfigKeys.DFS_NAMENODE_REPLICATION_STREAMS_HARD_LIMIT_KEY,

            DFSConfigKeys.DFS_NAMENODE_REPLICATION_STREAMS_HARD_LIMIT_DEFAULT);

    this.shouldCheckForEnoughRacks =

        conf.get(DFSConfigKeys.NET_TOPOLOGY_SCRIPT_FILE_NAME_KEY) == null

            ? false : true;

   

    this.replicationRecheckInterval =

      conf.getInt(DFSConfigKeys.DFS_NAMENODE_REPLICATION_INTERVAL_KEY,

                  DFSConfigKeys.DFS_NAMENODE_REPLICATION_INTERVAL_DEFAULT) * 1000L;

    LOG.info("defaultReplication = " + defaultReplication);

    LOG.info("maxReplication     = " + maxReplication);

    LOG.info("minReplication     = " + minReplication);

    LOG.info("maxReplicationStreams      = " + maxReplicationStreams);

    LOG.info("shouldCheckForEnoughRacks  = " + shouldCheckForEnoughRacks);

    LOG.info("replicationRecheckInterval = " + replicationRecheckInterval);

  }

  private static BlockTokenSecretManager createBlockTokenSecretManager(

      final Configuration conf) throws IOException {

    final boolean isEnabled = conf.getBoolean(

        DFSConfigKeys.DFS_BLOCK_ACCESS_TOKEN_ENABLE_KEY,

        DFSConfigKeys.DFS_BLOCK_ACCESS_TOKEN_ENABLE_DEFAULT);

    LOG.info(DFSConfigKeys.DFS_BLOCK_ACCESS_TOKEN_ENABLE_KEY + "=" + isEnabled);

    if (!isEnabled) {

      return null;

    }

    final long updateMin = conf.getLong(

        DFSConfigKeys.DFS_BLOCK_ACCESS_KEY_UPDATE_INTERVAL_KEY,

        DFSConfigKeys.DFS_BLOCK_ACCESS_KEY_UPDATE_INTERVAL_DEFAULT);

    final long lifetimeMin = conf.getLong(

        DFSConfigKeys.DFS_BLOCK_ACCESS_TOKEN_LIFETIME_KEY,

        DFSConfigKeys.DFS_BLOCK_ACCESS_TOKEN_LIFETIME_DEFAULT);

    LOG.info(DFSConfigKeys.DFS_BLOCK_ACCESS_KEY_UPDATE_INTERVAL_KEY

        + "=" + updateMin + " min(s), "

        + DFSConfigKeys.DFS_BLOCK_ACCESS_TOKEN_LIFETIME_KEY

        + "=" + lifetimeMin + " min(s)");

    return new BlockTokenSecretManager(true,

        updateMin*60*1000L, lifetimeMin*60*1000L);

  }

  /** get the BlockTokenSecretManager */

  BlockTokenSecretManager getBlockTokenSecretManager() {

    return blockTokenSecretManager;

  }

  private boolean isBlockTokenEnabled() {

    return blockTokenSecretManager != null;

  }

  /** Should the access keys be updated? */

  boolean shouldUpdateBlockKey(final long updateTime) throws IOException {

    return isBlockTokenEnabled()? blockTokenSecretManager.updateKeys(updateTime)

        : false;

  }

  public void activate(Configuration conf) {

    pendingReplications.start();

    datanodeManager.activate(conf);

    this.replicationThread.start();

  }

  public void close() {

    if (pendingReplications != null) pendingReplications.stop();

    blocksMap.close();

    datanodeManager.close();

    if (replicationThread != null) replicationThread.interrupt();

  }

  /** @return the datanodeManager */

  public DatanodeManager getDatanodeManager() {

    return datanodeManager;

  }

  /** @return the BlockPlacementPolicy */

  public BlockPlacementPolicy getBlockPlacementPolicy() {

    return blockplacement;

  }

  /** Set BlockPlacementPolicy */

  public void setBlockPlacementPolicy(BlockPlacementPolicy newpolicy) {

    if (newpolicy == null) {

      throw new HadoopIllegalArgumentException("newpolicy == null");

    }

    this.blockplacement = newpolicy;

  }

  /** Dump meta data to out. */

  public void metaSave(PrintWriter out) {

    assert namesystem.hasWriteLock();

    final List<DatanodeDescriptor> live = new ArrayList<DatanodeDescriptor>();

    final List<DatanodeDescriptor> dead = new ArrayList<DatanodeDescriptor>();

    datanodeManager.fetchDatanodes(live, dead, false);

    out.println("Live Datanodes: " + live.size());

    out.println("Dead Datanodes: " + dead.size());

    //

    // Dump contents of neededReplication

    //

    synchronized (neededReplications) {

      out.println("Metasave: Blocks waiting for replication: " +

                  neededReplications.size());

      for (Block block : neededReplications) {

        List<DatanodeDescriptor> containingNodes =

                                          new ArrayList<DatanodeDescriptor>();

        List<DatanodeDescriptor> containingLiveReplicasNodes =

          new ArrayList<DatanodeDescriptor>();

       

        NumberReplicas numReplicas = new NumberReplicas();

        // source node returned is not used

        chooseSourceDatanode(block, containingNodes,

            containingLiveReplicasNodes, numReplicas,

            UnderReplicatedBlocks.LEVEL);

        assert containingLiveReplicasNodes.size() == numReplicas.liveReplicas();

        int usableReplicas = numReplicas.liveReplicas() +

                             numReplicas.decommissionedReplicas();

      

        if (block instanceof BlockInfo) {

          String fileName = ((BlockInfo)block).getINode().getFullPathName();

          out.print(fileName + ": ");

        }

        // l: == live:, d: == decommissioned c: == corrupt e: == excess

        out.print(block + ((usableReplicas > 0)? "" : " MISSING") +

                  " (replicas:" +

                  " l: " + numReplicas.liveReplicas() +

                  " d: " + numReplicas.decommissionedReplicas() +

                  " c: " + numReplicas.corruptReplicas() +

                  " e: " + numReplicas.excessReplicas() + ") ");

        Collection<DatanodeDescriptor> corruptNodes =

                                      corruptReplicas.getNodes(block);

       

        for (Iterator<DatanodeDescriptor> jt = blocksMap.nodeIterator(block);

             jt.hasNext();) {

          DatanodeDescriptor node = jt.next();

          String state = "";

          if (corruptNodes != null && corruptNodes.contains(node)) {

            state = "(corrupt)";

          } else if (node.isDecommissioned() ||

              node.isDecommissionInProgress()) {

            state = "(decommissioned)";

          }         

          out.print(" " + node + state + " : ");

        }

        out.println("");

      }

    }

    // Dump blocks from pendingReplication

    pendingReplications.metaSave(out);

    // Dump blocks that are waiting to be deleted

    invalidateBlocks.dump(out);

    // Dump all datanodes

    getDatanodeManager().datanodeDump(out);

  }

  /** @return maxReplicationStreams */

  public int getMaxReplicationStreams() {

    return maxReplicationStreams;

  }

  /**

   * @param block

   * @return true if the block has minimum replicas

   */

  public boolean checkMinReplication(Block block) {

    return (countNodes(block).liveReplicas() >= minReplication);

  }

  /**

   * Commit a block of a file

   *

   * @param block block to be committed

   * @param commitBlock - contains client reported block length and generation

   * @return true if the block is changed to committed state.

   * @throws IOException if the block does not have at least a minimal number

   * of replicas reported from data-nodes.

   */

  private boolean commitBlock(final BlockInfoUnderConstruction block,

      final Block commitBlock) throws IOException {

    if (block.getBlockUCState() == BlockUCState.COMMITTED)

      return false;

    assert block.getNumBytes() <= commitBlock.getNumBytes() :

      "commitBlock length is less than the stored one "

      + commitBlock.getNumBytes() + " vs. " + block.getNumBytes();

    block.commitBlock(commitBlock);

    return true;

  }

 

  /**

   * Commit the last block of the file and mark it as complete if it has

   * meets the minimum replication requirement

   *

   * @param fileINode file inode

   * @param commitBlock - contains client reported block length and generation

   * @return true if the last block is changed to committed state.

   * @throws IOException if the block does not have at least a minimal number

   * of replicas reported from data-nodes.

   */

  public boolean commitOrCompleteLastBlock(INodeFileUnderConstruction fileINode,

      Block commitBlock) throws IOException {

    if(commitBlock == null)

      return false; // not committing, this is a block allocation retry

    BlockInfo lastBlock = fileINode.getLastBlock();

    if(lastBlock == null)

      return false; // no blocks in file yet

    if(lastBlock.isComplete())

      return false; // already completed (e.g. by syncBlock)

   

    final boolean b = commitBlock((BlockInfoUnderConstruction)lastBlock, commitBlock);

    if(countNodes(lastBlock).liveReplicas() >= minReplication)

      completeBlock(fileINode,fileINode.numBlocks()-1);

    return b;

  }

  /**

   * Convert a specified block of the file to a complete block.

   * @param fileINode file

   * @param blkIndex  block index in the file

   * @throws IOException if the block does not have at least a minimal number

   * of replicas reported from data-nodes.

   */

  private BlockInfo completeBlock(final INodeFile fileINode,

      final int blkIndex) throws IOException {

    return completeBlock(fileINode, blkIndex, false);

  }

  public BlockInfo completeBlock(final INodeFile fileINode,

      final int blkIndex, final boolean force) throws IOException {

    if(blkIndex < 0)

      return null;

    BlockInfo curBlock = fileINode.getBlocks()[blkIndex];

    if(curBlock.isComplete())

      return curBlock;

    BlockInfoUnderConstruction ucBlock = (BlockInfoUnderConstruction)curBlock;

    if(!force && ucBlock.numNodes() < minReplication)

      throw new IOException("Cannot complete block: " +

          "block does not satisfy minimal replication requirement.");

    if(!force && ucBlock.getBlockUCState() != BlockUCState.COMMITTED)

      throw new IOException(

          "Cannot complete block: block has not been COMMITTED by the client");

    BlockInfo completeBlock = ucBlock.convertToCompleteBlock();

    // replace penultimate block in file

    fileINode.setBlock(blkIndex, completeBlock);

    // replace block in the blocksMap

    return blocksMap.replaceBlock(completeBlock);

  }

  private BlockInfo completeBlock(final INodeFile fileINode,

      final BlockInfo block) throws IOException {

    BlockInfo[] fileBlocks = fileINode.getBlocks();

    for(int idx = 0; idx < fileBlocks.length; idx++)

      if(fileBlocks[idx] == block) {

        return completeBlock(fileINode, idx);

      }

    return block;

  }

  /**

   * Convert the last block of the file to an under construction block.<p>

   * The block is converted only if the file has blocks and the last one

   * is a partial block (its size is less than the preferred block size).

   * The converted block is returned to the client.

   * The client uses the returned block locations to form the data pipeline

   * for this block.<br>

   * The methods returns null if there is no partial block at the end.

   * The client is supposed to allocate a new block with the next call.

   *

   * @param fileINode file

   * @return the last block locations if the block is partial or null otherwise

   */

  public LocatedBlock convertLastBlockToUnderConstruction(

      INodeFileUnderConstruction fileINode) throws IOException {

    BlockInfo oldBlock = fileINode.getLastBlock();

    if(oldBlock == null ||

        fileINode.getPreferredBlockSize() == oldBlock.getNumBytes())

      return null;

    assert oldBlock == getStoredBlock(oldBlock) :

      "last block of the file is not in blocksMap";

    DatanodeDescriptor[] targets = getNodes(oldBlock);

    BlockInfoUnderConstruction ucBlock =

      fileINode.setLastBlock(oldBlock, targets);

    blocksMap.replaceBlock(ucBlock);

    // Remove block from replication queue.

    updateNeededReplications(oldBlock, 0, 0);

    // remove this block from the list of pending blocks to be deleted.

    for (DatanodeDescriptor dd : targets) {

      String datanodeId = dd.getStorageID();

      invalidateBlocks.remove(datanodeId, oldBlock);

    }

    final long fileLength = fileINode.computeContentSummary().getLength();

    final long pos = fileLength - ucBlock.getNumBytes();

    return createLocatedBlock(ucBlock, pos, AccessMode.WRITE);

  }

  /**

   * Get all valid locations of the block

   */

  private List<String> getValidLocations(Block block) {

    ArrayList<String> machineSet =

      new ArrayList<String>(blocksMap.numNodes(block));

    for(Iterator<DatanodeDescriptor> it =

      blocksMap.nodeIterator(block); it.hasNext();) {

      String storageID = it.next().getStorageID();

      // filter invalidate replicas

      if(!invalidateBlocks.contains(storageID, block)) {

        machineSet.add(storageID);

      }

    }

    return machineSet;

  }

  private List<LocatedBlock> createLocatedBlockList(final BlockInfo[] blocks,

      final long offset, final long length, final int nrBlocksToReturn,

      final AccessMode mode) throws IOException {

    int curBlk = 0;

    long curPos = 0, blkSize = 0;

    int nrBlocks = (blocks[0].getNumBytes() == 0) ? 0 : blocks.length;

    for (curBlk = 0; curBlk < nrBlocks; curBlk++) {

      blkSize = blocks[curBlk].getNumBytes();

      assert blkSize > 0 : "Block of size 0";

      if (curPos + blkSize > offset) {

        break;

      }

      curPos += blkSize;

    }

    if (nrBlocks > 0 && curBlk == nrBlocks)   // offset >= end of file

      return Collections.<LocatedBlock>emptyList();

    long endOff = offset + length;

    List<LocatedBlock> results = new ArrayList<LocatedBlock>(blocks.length);

    do {

      results.add(createLocatedBlock(blocks[curBlk], curPos, mode));

      curPos += blocks[curBlk].getNumBytes();

      curBlk++;

    } while (curPos < endOff

          && curBlk < blocks.length

          && results.size() < nrBlocksToReturn);

    return results;

  }

  private LocatedBlock createLocatedBlock(final BlockInfo blk, final long pos,

    final BlockTokenSecretManager.AccessMode mode) throws IOException {

    final LocatedBlock lb = createLocatedBlock(blk, pos);

    if (mode != null) {

      setBlockToken(lb, mode);

    }

    return lb;

  }

  /** @return a LocatedBlock for the given block */

  private LocatedBlock createLocatedBlock(final BlockInfo blk, final long pos

      ) throws IOException {

    if (blk instanceof BlockInfoUnderConstruction) {

      if (blk.isComplete()) {

        throw new IOException(

            "blk instanceof BlockInfoUnderConstruction && blk.isComplete()"

            + ", blk=" + blk);

      }

      final BlockInfoUnderConstruction uc = (BlockInfoUnderConstruction)blk;

      final DatanodeDescriptor[] locations = uc.getExpectedLocations();

      final ExtendedBlock eb = new ExtendedBlock(namesystem.getBlockPoolId(), blk);

      return new LocatedBlock(eb, locations, pos, false);

    }

    // get block locations

    final int numCorruptNodes = countNodes(blk).corruptReplicas();

    final int numCorruptReplicas = corruptReplicas.numCorruptReplicas(blk);

    if (numCorruptNodes != numCorruptReplicas) {

      LOG.warn("Inconsistent number of corrupt replicas for "

          + blk + " blockMap has " + numCorruptNodes

          + " but corrupt replicas map has " + numCorruptReplicas);

    }

    final int numNodes = blocksMap.numNodes(blk);

    final boolean isCorrupt = numCorruptNodes == numNodes;

    final int numMachines = isCorrupt ? numNodes: numNodes - numCorruptNodes;

    final DatanodeDescriptor[] machines = new DatanodeDescriptor[numMachines];

    if (numMachines > 0) {

      int j = 0;

      for(Iterator<DatanodeDescriptor> it = blocksMap.nodeIterator(blk);

          it.hasNext();) {

        final DatanodeDescriptor d = it.next();

        final boolean replicaCorrupt = corruptReplicas.isReplicaCorrupt(blk, d);

        if (isCorrupt || (!isCorrupt && !replicaCorrupt))

          machines[j++] = d;

      }

    }

    final ExtendedBlock eb = new ExtendedBlock(namesystem.getBlockPoolId(), blk);

    return new LocatedBlock(eb, machines, pos, isCorrupt);

  }

  /** Create a LocatedBlocks. */

  public LocatedBlocks createLocatedBlocks(final BlockInfo[] blocks,

      final long fileSizeExcludeBlocksUnderConstruction,

      final boolean isFileUnderConstruction,

      final long offset, final long length, final boolean needBlockToken

      ) throws IOException {

    assert namesystem.hasReadOrWriteLock();

    if (blocks == null) {

      return null;

    } else if (blocks.length == 0) {

      return new LocatedBlocks(0, isFileUnderConstruction,

          Collections.<LocatedBlock>emptyList(), null, false);

    } else {

      if (LOG.isDebugEnabled()) {

        LOG.debug("blocks = " + java.util.Arrays.asList(blocks));

      }

      final AccessMode mode = needBlockToken? AccessMode.READ: null;

      final List<LocatedBlock> locatedblocks = createLocatedBlockList(

          blocks, offset, length, Integer.MAX_VALUE, mode);

      final BlockInfo last = blocks[blocks.length - 1];

      final long lastPos = last.isComplete()?

          fileSizeExcludeBlocksUnderConstruction - last.getNumBytes()

          : fileSizeExcludeBlocksUnderConstruction;

      final LocatedBlock lastlb = createLocatedBlock(last, lastPos, mode);

      return new LocatedBlocks(

          fileSizeExcludeBlocksUnderConstruction, isFileUnderConstruction,

          locatedblocks, lastlb, last.isComplete());

    }

  }

  /** @return current access keys. */

  public ExportedBlockKeys getBlockKeys() {

    return isBlockTokenEnabled()? blockTokenSecretManager.exportKeys()

        : ExportedBlockKeys.DUMMY_KEYS;

  }

  /** Generate a block token for the located block. */

  public void setBlockToken(final LocatedBlock b,

      final BlockTokenSecretManager.AccessMode mode) throws IOException {

    if (isBlockTokenEnabled()) {

      b.setBlockToken(blockTokenSecretManager.generateToken(b.getBlock(),

          EnumSet.of(mode)));

    }   

  }

  void addKeyUpdateCommand(final List<DatanodeCommand> cmds,

      final DatanodeDescriptor nodeinfo) {

    // check access key update

    if (isBlockTokenEnabled() && nodeinfo.needKeyUpdate) {