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

网格计算

开发平台:

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.datanode;
  19. import java.io.BufferedInputStream;
  20. import java.io.DataInputStream;
  21. import java.io.DataOutputStream;
  22. import java.io.File;
  23. import java.io.FileInputStream;
  24. import java.io.IOException;
  25. import org.apache.hadoop.io.IOUtils;
  26. import org.apache.hadoop.util.DataChecksum;
  27. /**
  28.  * BlockMetadataHeader manages metadata for data blocks on Datanodes.
  29.  * This is not related to the Block related functionality in Namenode.
  30.  * The biggest part of data block metadata is CRC for the block.
  31.  */
  32. class BlockMetadataHeader {
  33.   static final short METADATA_VERSION = FSDataset.METADATA_VERSION;
  34.   
  35.   /**
  36.    * Header includes everything except the checksum(s) themselves.
  37.    * Version is two bytes. Following it is the DataChecksum
  38.    * that occupies 5 bytes. 
  39.    */
  40.   private short version;
  41.   private DataChecksum checksum = null;
  42.     
  43.   BlockMetadataHeader(short version, DataChecksum checksum) {
  44.     this.checksum = checksum;
  45.     this.version = version;
  46.   }
  47.     
  48.   short getVersion() {
  49.     return version;
  50.   }
  51.   DataChecksum getChecksum() {
  52.     return checksum;
  53.   }
  54.  
  55.   /**
  56.    * This reads all the fields till the beginning of checksum.
  57.    * @param in 
  58.    * @return Metadata Header
  59.    * @throws IOException
  60.    */
  61.   static BlockMetadataHeader readHeader(DataInputStream in) throws IOException {
  62.     return readHeader(in.readShort(), in);
  63.   }
  64.   
  65.   /**
  66.    * Reads header at the top of metadata file and returns the header.
  67.    * 
  68.    * @param dataset
  69.    * @param block
  70.    * @return
  71.    * @throws IOException
  72.    */
  73.   static BlockMetadataHeader readHeader(File file) throws IOException {
  74.     DataInputStream in = null;
  75.     try {
  76.       in = new DataInputStream(new BufferedInputStream(
  77.                                new FileInputStream(file)));
  78.       return readHeader(in);
  79.     } finally {
  80.       IOUtils.closeStream(in);
  81.     }
  82.   }
  83.   
  84.   // Version is already read.
  85.   private static BlockMetadataHeader readHeader(short version, DataInputStream in) 
  86.                                    throws IOException {
  87.     DataChecksum checksum = DataChecksum.newDataChecksum(in);
  88.     return new BlockMetadataHeader(version, checksum);
  89.   }
  90.   
  91.   /**
  92.    * This writes all the fields till the beginning of checksum.
  93.    * @param out DataOutputStream
  94.    * @param header 
  95.    * @return 
  96.    * @throws IOException
  97.    */
  98.   private static void writeHeader(DataOutputStream out, 
  99.                                   BlockMetadataHeader header) 
  100.                                   throws IOException {
  101.     out.writeShort(header.getVersion());
  102.     header.getChecksum().writeHeader(out);
  103.   }
  104.   
  105.   /**
  106.    * Writes all the fields till the beginning of checksum.
  107.    * @param out
  108.    * @param checksum
  109.    * @throws IOException
  110.    */
  111.   static void writeHeader(DataOutputStream out, DataChecksum checksum)
  112.                          throws IOException {
  113.     writeHeader(out, new BlockMetadataHeader(METADATA_VERSION, checksum));
  114.   }
  115.   /**
  116.    * Returns the size of the header
  117.    */
  118.   static int getHeaderSize() {
  119.     return Short.SIZE/Byte.SIZE + DataChecksum.getChecksumHeaderSize();
  120.   }
  121. }