DataNode節點上數據塊的完整性——DataBlockScanner

由於每一個磁盤或者是網絡上的I/O操作可能會對正在讀寫的數據處理不慎而出現錯誤，所以HDFS提供了下面兩種數據檢驗方式，以此來保證數據的完整性，而且這兩種檢驗方式在DataNode節點上是同時工作的：

一.校驗和

       檢測損壞數據的常用方法是在第一次進行系統時計算數據的校驗和，在通道傳輸過程中，如果新生成的校驗和不完全匹配原始的校驗和，那麼數據就會被認爲是被損壞的。

二.數據塊檢測程序(DataBlockScanner)

     在DataNode節點上開啓一個後臺線程，來定期驗證存儲在它上所有塊，這個是防止物理介質出現損減情況而造成的數據損壞。

        關於校驗和，HDFS以透明的方式檢驗所有寫入它的數據，並在默認設置下，會在讀取數據時驗證校驗和。正對數據的每一個校驗塊，都會創建一個單獨的校驗和，默認校驗塊大小是512字節，對應的校驗和是4字節。DataNode節點負載在存儲數據(當然包括數據的校驗和)之前驗證它們收到的數據，如果此DataNode節點檢測到錯誤，客戶端會收到一個CheckSumException。客戶端讀取DataNode節點上的數據時，會驗證校驗和，即將其與DataNode上存儲的校驗和進行比較。每一個DataNode節點都會維護着一個連續的校驗和和驗證日誌，裏面有着每一個Block的最後驗證時間。客戶端成功驗證Block之後，便會告訴DataNode節點，Datanode節點隨之更新日誌。這一點也就涉及到前面說的DataBlockScanner了，所以接下來我將主要討論DataBlockScanner。

     還是先來看看與DataBlockScanner相關聯的類吧！

dataset：數據塊管理器；
blockInfoSet：數據塊掃描信息集合，按照上一次掃描時間和數據塊id升序排序，以便快速獲取驗證到期的數據塊；
blockMap：數據塊和數據塊掃描信息的映射，以便能夠根據數據塊快速獲取對應的掃描信息；
totalBytesToScan：一個掃描週期中需要掃描的總數據量；

bytesLeft：一個掃描週期中還剩下需要掃描的數據量；

throttler：掃描時I/O速度控制器，需要根據totalBytesToScan和bytesLeft信息來衡量；

verificationLog：數據塊的掃描驗證日誌記錄器；

scanPeriod：一個掃描週期，可以由Datanode的配置文件來設置，配置項是：dfs.datanode.scan.period.hours，單位是小時，默認的值是21*24*60*60*1000 ms。

    DataBlockScanner是作爲DataNode的一個後臺線程工作的，跟着DataNode一塊啓動，它的工作流程如下：

   DataBlockScanner被DataNode節點用來檢測它所管理的所有Block數據塊的一致性，因此，對已DataNode節點上的每一個Block，它都會每隔scanPeriod ms利用Block對應的校驗和文件來檢測該Block一次，看看這個Block的數據是否已經損壞。由於scanPeriod 的值一般比較大，因爲對DataNode節點上的每一個Block掃描一遍要消耗不少系統資源，這就可能帶來另外一個問題就是在一個掃描週期內可能會出現DataNode節點重啓的情況，所以爲了提供系統性能，避免DataNode節點在啓動之後對還沒有過期的Block又掃描一遍，DataBlockScanner在其內部使用了日誌記錄器來持久化保存每一個Block上一次掃描的時間，這樣的話， DataNode節點在啓動之後通過日誌文件來恢復之前所有Block的有效時間。另外，DataNode爲了節約系統資源，它對Block的驗證不僅僅只依賴於DataBlockScanner後臺線程(VERIFICATION_SCAN方式)，他還會在向某一個客戶端傳送Block的時候來更行該Block的掃描時間(REMOTE_READ方式)，這是因爲DataNode向客戶端傳送一個Block的時候要必須校驗該數據塊。那麼這個時候日誌記錄器並不會馬上把該數據塊的掃描信息寫到日誌，畢竟頻繁的磁盤I/O會導致性能下降，至於何時對該Block的最新掃描時間寫日誌有一個判斷條件：

    1.如果是VERIFICATION_SCAN方式的Block驗證，必須記日誌；

    2.如果是REMOTE_READ方式，那麼該Block上一次的記錄日誌到現在的時間間隔超過24小時或者超過scanPeriod/3 ms 的話，記日誌。

   下面來結合源碼詳細討論這個過程：

1.初始化

   在整個掃描驗證過程中都一個速度控制器，

[java] view plaincopy

1.    private void init() {  
2.     Block arr[] = dataset.getBlockReport();//從“磁盤”上獲取所有的數據塊基本信息  
3.     Collections.shuffle(Arrays.asList(arr));  
4.       
5.     blockInfoSet = new TreeSet<BlockScanInfo>();  
6.     blockMap = new HashMap<Block, BlockScanInfo>();  
7.       
8.     long scanTime = -1;  
9.     for (Block block : arr) {  
10.       //爲每一個Block建立掃描驗證信息  
11.       BlockScanInfo info = new BlockScanInfo( block );  
12.       info.lastScanTime = scanTime--;   
13.       addBlockInfo(info);  
14.     }  
15.   
16.     /* 尋找一個合適的掃描驗證日誌文件 
17.      */  
18.     File dir = null;  
19.     FSDataset.FSVolume[] volumes = dataset.volumes.volumes;  
20.     for(FSDataset.FSVolume vol : volumes) {  
21.       if (LogFileHandler.isFilePresent(vol.getDir(), verificationLogFile)) {  
22.         dir = vol.getDir();  
23.         break;  
24.       }  
25.     }  
26.     if (dir == null) {  
27.       dir = volumes[0].getDir();  
28.     }  
29.       
30.     try {  
31.       // 創建一個日誌記錄器  
32.       verificationLog = new LogFileHandler(dir, verificationLogFile, 100);  
33.     } catch (IOException e) {  
34.       LOG.warn("Could not open verfication log. " + "Verification times are not stored.");  
35.     }  
36.       
37.     synchronized (this) {  
38.       //創建一個掃描速度控制器  
39.       throttler = new BlockTransferThrottler(200, MAX_SCAN_RATE);  
40.     }  
41.   }  
42.   
43.  private void updateBytesToScan(long len, long lastScanTime) {  
44.     // len could be negative when a block is deleted.  
45.     totalBytesToScan += len;  
46.     //新添加的Block需要在需要在此次中掃描驗證  
47.     if ( lastScanTime < currentPeriodStart ) {  
48.       bytesLeft += len;  
49.     }  
50.   }  
51.   
52.   private synchronized void addBlockInfo(BlockScanInfo info) {  
53.     boolean added = blockInfoSet.add(info);  
54.     blockMap.put(info.block, info);  
55.       
56.     if ( added ) {  
57.       LogFileHandler log = verificationLog;  
58.       if (log != null) {  
59.         log.setMaxNumLines(blockMap.size() * verficationLogLimit);  
60.       }  
61.       //用新添加的Block掃描信息來更新此次掃描的任務量  
62.       updateBytesToScan(info.block.getNumBytes(), info.lastScanTime);  
63.     }  
64.   }  

    這個日誌文件dncp_block_verification.log.curr保存在DataNode節點的一個存儲目錄中，並放在current/目錄下，如：

2.初始化上一次驗證時間

[java] view plaincopy

1. private synchronized void delBlockInfo(BlockScanInfo info) {  
2.    boolean exists = blockInfoSet.remove(info);  
3.    blockMap.remove(info.block);  
4.    if ( exists ) {  
5.      LogFileHandler log = verificationLog;  
6.      if (log != null) {  
7.        log.setMaxNumLines(blockMap.size() * verficationLogLimit);  
8.      }  
9.      //更新此次掃描驗證的工作量  
10.      updateBytesToScan(-info.block.getNumBytes(), info.lastScanTime);  
11.    }  
12.  }  
13.   
14.  private synchronized void updateBlockInfo(LogEntry e) {  
15.    BlockScanInfo info = blockMap.get(new Block(e.blockId, 0, e.genStamp));  
16.    if(info != null && e.verificationTime > 0 && info.lastScanTime < e.verificationTime) {  
17.      delBlockInfo(info);  
18.      info.lastScanTime = e.verificationTime;  
19.      info.lastScanType = ScanType.VERIFICATION_SCAN;  
20.      addBlockInfo(info);  
21.    }  
22.  }  
23.   
24.  //爲每一個Block分配上一次驗證的時間  
25.  private boolean assignInitialVerificationTimes() {  
26.    int numBlocks = 1;  
27.    synchronized (this) {  
28.      numBlocks = Math.max(blockMap.size(), 1);  
29.    }  
30.      
31.    //讀取數據塊的驗證日誌文件  
32.    LogFileHandler.Reader logReader = null;  
33.    try {  
34.      if (verificationLog != null) {  
35.        logReader = verificationLog.new Reader(false);  
36.      }  
37.    } catch (IOException e) {  
38.      LOG.warn("Could not read previous verification times : " + StringUtils.stringifyException(e));  
39.    }  
40.      
41.    if (verificationLog != null) {  
42.      verificationLog.updateCurNumLines();  
43.    }  
44.      
45.    try {  
46.    //用日誌信息來更新記錄的Block上一次驗證時間  
47.    while (logReader != null && logReader.hasNext()) {  
48.      if (!datanode.shouldRun || Thread.interrupted()) {  
49.        return false;  
50.      }  
51.      LogEntry entry = LogEntry.parseEntry(logReader.next());  
52.      if (entry != null) {  
53.        updateBlockInfo(entry);  
54.      }  
55.    }  
56.    } finally {  
57.      IOUtils.closeStream(logReader);  
58.    }  
59.      
60.    /* 計算Blocks之間驗證的間隔時間 
61.     */  
62.    long verifyInterval = (long) (Math.min( scanPeriod/2.0/numBlocks, 10*60*1000 ));  
63.    long lastScanTime = System.currentTimeMillis() - scanPeriod;  
64.      
65.    /* 初始化剩餘Blocks的上一次驗證時間 
66.     */      
67.    synchronized (this) {  
68.      if (blockInfoSet.size() > 0 ) {  
69.        BlockScanInfo info;  
70.        while ((info =  blockInfoSet.first()).lastScanTime < 0) {  
71.          delBlockInfo(info);          
72.          info.lastScanTime = lastScanTime;  
73.          lastScanTime += verifyInterval;  
74.          addBlockInfo(info);  
75.        }  
76.      }  
77.    }  
78.      
79.    return true;  
80.  }  
81.    

3.調整掃描速度

   在一次Blocks掃描驗證週期中，DataBlockScanner需要進行大量的磁盤I/O，爲了不影響DataNode節點上其它線程的工作資源，同時也爲了自身工作的有效性，所以DataBlockScanner採用了掃描驗證速度控制器，根據當前的工作量來控制當前數據塊的驗證速度。

[java] view plaincopy

1. private synchronized void adjustThrottler() {  
2.    //本次掃描驗證還剩餘的時間  
3.    long timeLeft = currentPeriodStart+scanPeriod - System.currentTimeMillis();  
4.    //根據本次驗證掃描剩餘的工作量和時間來計算速度  
5.    long bw = Math.max(bytesLeft*1000/timeLeft, MIN_SCAN_RATE);  
6.    throttler.setBandwidth(Math.min(bw, MAX_SCAN_RATE));  
7.  }  

4.數據塊的掃描驗證

    DataNode節點在向客戶端或者其它DataNode節點傳輸數據時，客戶端或者其它DataNode節點會根據接收的數據校驗和來驗證接收到的數據，當驗證出錯時，它們會通知傳送節點。DataBlockScanner通過自己扮演傳輸者又扮演接受者來實現數據塊的驗證的；同時爲了防止本地磁盤的I/O的錯誤，DataBlockScanner採用了兩次傳輸-接收來確保驗證的Block的數據是出錯了(損壞了)。當發現有出錯的Block是，就需要向NameNode節點報告，由NameNode來決定如何處理這個數據塊，而不是由DataNode節點擅自作主清除該Block數據信息。

[java] view plaincopy

1.   private void verifyBlock(Block block) {  
2.       
3.     BlockSender blockSender = null;  
4.     for (int i=0; i<2; i++) {  
5.       boolean second = (i > 0);  
6.         
7.       try {  
8.         adjustThrottler();  
9.           
10.         blockSender = new BlockSender(block, 0, -1, false, false, true, datanode);  
11.   
12.         DataOutputStream out = new DataOutputStream(new IOUtils.NullOutputStream());  
13.           
14.         blockSender.sendBlock(out, null, throttler);  
15.   
16.         LOG.info((second ? "Second " : "") + "Verification succeeded for " + block);  
17.           
18.         if ( second ) {  
19.           totalTransientErrors++;  
20.         }  
21.           
22.         updateScanStatus(block, ScanType.VERIFICATION_SCAN, true);  
23.   
24.         return;  
25.       } catch (IOException e) {  
26.   
27.         totalScanErrors++;  
28.         updateScanStatus(block, ScanType.VERIFICATION_SCAN, false);  
29.   
30.         //在“磁盤”上沒有該Block對應的文件  
31.        if ( dataset.getFile(block) == null ) {  
32.           LOG.info("Verification failed for " + block + ". Its ok since " + "it not in datanode dataset anymore.");  
33.           deleteBlock(block);  
34.           return;  
35.         }  
36.   
37.         LOG.warn((second ? "Second " : "First ") + "Verification failed for " + block + ". Exception : " + StringUtils.stringifyException(e));  
38.           
39.         //兩次驗證都出錯  
40.         if (second) {  
41.           datanode.getMetrics().blockVerificationFailures.inc();   
42.           handleScanFailure(block);  
43.           return;  
44.         }   
45.       } finally {  
46.         IOUtils.closeStream(blockSender);  
47.         datanode.getMetrics().blocksVerified.inc();  
48.         totalScans++;  
49.         totalVerifications++;  
50.       }  
51.     }  
52.   
53.   private synchronized void updateScanStatus(Block block, ScanType type, boolean scanOk) {  
54.     BlockScanInfo info = blockMap.get(block);  
55.       
56.     if ( info != null ) {  
57.       delBlockInfo(info);  
58.     } else {  
59.       // It might already be removed. Thats ok, it will be caught next time.  
60.       info = new BlockScanInfo(block);  
61.     }  
62.       
63.     //更新該Block的驗證信息  
64.     long now = System.currentTimeMillis();  
65.     info.lastScanType = type;  
66.     info.lastScanTime = now;  
67.     info.lastScanOk = scanOk;  
68.     addBlockInfo(info);  
69.       
70.     if (type == ScanType.REMOTE_READ) {  
71.       totalVerifications++;  
72.     }  
73.           
74.     // Don't update meta data too often in case of REMOTE_READ  
75.     // of if the verification failed.  
76.     long diff = now - info.lastLogTime;  
77.     if (!scanOk || (type == ScanType.REMOTE_READ &&  diff < scanPeriod/3 && diff < ONE_DAY)) {  
78.       return;  
79.     }  
80.       
81.     info.lastLogTime = now;  
82.     LogFileHandler log = verificationLog;  
83.     if (log != null) {  
84.       log.appendLine(LogEntry.newEnry(block, now));//記錄通過驗證的Block驗證信息  
85.     }  
86.   }  
87.     
88.   //處理髮生錯誤的Block  
89.   private void handleScanFailure(Block block) {  
90.         
91.     try {  
92.       DatanodeInfo[] dnArr = { new DatanodeInfo(datanode.dnRegistration) };  
93.       LocatedBlock[] blocks = { new LocatedBlock(block, dnArr) };   
94.         
95.       //向NameNode節點發送出錯的Block  
96.       datanode.namenode.reportBadBlocks(blocks);  
97.     } catch (IOException e){  
98.       /* One common reason is that NameNode could be in safe mode. 
99.        * Should we keep on retrying in that case? 
100.        */  
101.       LOG.warn("Failed to report bad block " + block + " to namenode : " +  " Exception : " + StringUtils.stringifyException(e));  
102.     }