CorruptReplicasMap.java
上传用户:quxuerui
上传日期:2018-01-08
资源大小:41811k
文件大小:5k
源码类别:

网格计算

开发平台:

Java

  1. /**
  2.  * Licensed to the Apache Software Foundation (ASF) under one
  3.  * or more contributor license agreements.  See the NOTICE file
  4.  * distributed with this work for additional information
  5.  * regarding copyright ownership.  The ASF licenses this file
  6.  * to you under the Apache License, Version 2.0 (the
  7.  * "License"); you may not use this file except in compliance
  8.  * with the License.  You may obtain a copy of the License at
  9.  *
  10.  *     http://www.apache.org/licenses/LICENSE-2.0
  11.  *
  12.  * Unless required by applicable law or agreed to in writing, software
  13.  * distributed under the License is distributed on an "AS IS" BASIS,
  14.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15.  * See the License for the specific language governing permissions and
  16.  * limitations under the License.
  17.  */
  18. package org.apache.hadoop.hdfs.server.namenode;
  19. import org.apache.hadoop.hdfs.protocol.Block;
  20. import org.apache.hadoop.ipc.Server;
  21. import java.util.*;
  22. /**
  23.  * Stores information about all corrupt blocks in the File System.
  24.  * A Block is considered corrupt only if all of its replicas are
  25.  * corrupt. While reporting replicas of a Block, we hide any corrupt
  26.  * copies. These copies are removed once Block is found to have 
  27.  * expected number of good replicas.
  28.  * Mapping: Block -> TreeSet<DatanodeDescriptor> 
  29.  */
  30. public class CorruptReplicasMap{
  31.   private Map<Block, Collection<DatanodeDescriptor>> corruptReplicasMap =
  32.     new TreeMap<Block, Collection<DatanodeDescriptor>>();
  33.   
  34.   /**
  35.    * Mark the block belonging to datanode as corrupt.
  36.    *
  37.    * @param blk Block to be added to CorruptReplicasMap
  38.    * @param dn DatanodeDescriptor which holds the corrupt replica
  39.    */
  40.   public void addToCorruptReplicasMap(Block blk, DatanodeDescriptor dn) {
  41.     Collection<DatanodeDescriptor> nodes = getNodes(blk);
  42.     if (nodes == null) {
  43.       nodes = new TreeSet<DatanodeDescriptor>();
  44.       corruptReplicasMap.put(blk, nodes);
  45.     }
  46.     if (!nodes.contains(dn)) {
  47.       nodes.add(dn);
  48.       NameNode.stateChangeLog.info("BLOCK NameSystem.addToCorruptReplicasMap: "+
  49.                                    blk.getBlockName() +
  50.                                    " added as corrupt on " + dn.getName() +
  51.                                    " by " + Server.getRemoteIp());
  52.     } else {
  53.       NameNode.stateChangeLog.info("BLOCK NameSystem.addToCorruptReplicasMap: "+
  54.                                    "duplicate requested for " + 
  55.                                    blk.getBlockName() + " to add as corrupt " +
  56.                                    "on " + dn.getName() +
  57.                                    " by " + Server.getRemoteIp());
  58.     }
  59.     if (NameNode.getNameNodeMetrics() != null) {
  60.       NameNode.getNameNodeMetrics().numBlocksCorrupted.set(
  61.         corruptReplicasMap.size());
  62.     }
  63.   }
  64.   /**
  65.    * Remove Block from CorruptBlocksMap
  66.    *
  67.    * @param blk Block to be removed
  68.    */
  69.   void removeFromCorruptReplicasMap(Block blk) {
  70.     if (corruptReplicasMap != null) {
  71.       corruptReplicasMap.remove(blk);
  72.       if (NameNode.getNameNodeMetrics() != null) {
  73.         NameNode.getNameNodeMetrics().numBlocksCorrupted.set(
  74.           corruptReplicasMap.size());
  75.       }
  76.     }
  77.   }
  78.   /**
  79.    * Remove the block at the given datanode from CorruptBlockMap
  80.    * @param blk block to be removed
  81.    * @param datanode datanode where the block is located
  82.    * @return true if the removal is successful; 
  83.              false if the replica is not in the map
  84.    */ 
  85.   boolean removeFromCorruptReplicasMap(Block blk, DatanodeDescriptor datanode) {
  86.     Collection<DatanodeDescriptor> datanodes = corruptReplicasMap.get(blk);
  87.     if (datanodes==null)
  88.       return false;
  89.     if (datanodes.remove(datanode)) { // remove the replicas
  90.       if (datanodes.isEmpty()) {
  91.         // remove the block if there is no more corrupted replicas
  92.         corruptReplicasMap.remove(blk);
  93.       }
  94.       return true;
  95.     }
  96.     return false;
  97.   }
  98.     
  99.   /**
  100.    * Get Nodes which have corrupt replicas of Block
  101.    * 
  102.    * @param blk Block for which nodes are requested
  103.    * @return collection of nodes. Null if does not exists
  104.    */
  105.   Collection<DatanodeDescriptor> getNodes(Block blk) {
  106.     return corruptReplicasMap.get(blk);
  107.   }
  108.   /**
  109.    * Check if replica belonging to Datanode is corrupt
  110.    *
  111.    * @param blk Block to check
  112.    * @param node DatanodeDescriptor which holds the replica
  113.    * @return true if replica is corrupt, false if does not exists in this map
  114.    */
  115.   boolean isReplicaCorrupt(Block blk, DatanodeDescriptor node) {
  116.     Collection<DatanodeDescriptor> nodes = getNodes(blk);
  117.     return ((nodes != null) && (nodes.contains(node)));
  118.   }
  119.   public int numCorruptReplicas(Block blk) {
  120.     Collection<DatanodeDescriptor> nodes = getNodes(blk);
  121.     return (nodes == null) ? 0 : nodes.size();
  122.   }
  123.   
  124.   public int size() {
  125.     return corruptReplicasMap.size();
  126.   }
  127. }