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

网格计算

开发平台:

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.DataInputStream;
  20. import java.io.IOException;
  21. import java.io.InputStream;
  22. import java.io.OutputStream;
  23. import junit.framework.TestCase;
  24. import org.apache.hadoop.conf.Configuration;
  25. import org.apache.hadoop.hdfs.protocol.Block;
  26. import org.apache.hadoop.hdfs.server.datanode.FSDatasetInterface;
  27. import org.apache.hadoop.hdfs.server.datanode.SimulatedFSDataset;
  28. import org.apache.hadoop.util.DataChecksum;
  29. /**
  30.  * this class tests the methods of the  SimulatedFSDataset.
  31.  *
  32.  */
  33. public class TestSimulatedFSDataset extends TestCase {
  34.   
  35.   Configuration conf = null;
  36.   
  37.   
  38.   static final int NUMBLOCKS = 20;
  39.   static final int BLOCK_LENGTH_MULTIPLIER = 79;
  40.   protected void setUp() throws Exception {
  41.     super.setUp();
  42.       conf = new Configuration();
  43.       conf.setBoolean(SimulatedFSDataset.CONFIG_PROPERTY_SIMULATED, true);
  44.  
  45.   }
  46.   protected void tearDown() throws Exception {
  47.     super.tearDown();
  48.   }
  49.   
  50.   long blockIdToLen(long blkid) {
  51.     return blkid*BLOCK_LENGTH_MULTIPLIER;
  52.   }
  53.   
  54.   int addSomeBlocks(FSDatasetInterface fsdataset, int startingBlockId) throws IOException {
  55.     int bytesAdded = 0;
  56.     for (int i = startingBlockId; i < startingBlockId+NUMBLOCKS; ++i) {
  57.       Block b = new Block(i, 0, 0); // we pass expected len as zero, - fsdataset should use the sizeof actual data written
  58.       OutputStream dataOut  = fsdataset.writeToBlock(b, false).dataOut;
  59.       assertEquals(0, fsdataset.getLength(b));
  60.       for (int j=1; j <= blockIdToLen(i); ++j) {
  61.         dataOut.write(j);
  62.         assertEquals(j, fsdataset.getLength(b)); // correct length even as we write
  63.         bytesAdded++;
  64.       }
  65.       dataOut.close();
  66.       b.setNumBytes(blockIdToLen(i));
  67.       fsdataset.finalizeBlock(b);
  68.       assertEquals(blockIdToLen(i), fsdataset.getLength(b));
  69.     }
  70.     return bytesAdded;  
  71.   }
  72.   int addSomeBlocks(FSDatasetInterface fsdataset ) throws IOException {
  73.     return addSomeBlocks(fsdataset, 1);
  74.   }
  75.   public void testGetMetaData() throws IOException {
  76.     FSDatasetInterface fsdataset = new SimulatedFSDataset(conf); 
  77.     Block b = new Block(1, 5, 0);
  78.     try {
  79.       assertFalse(fsdataset.metaFileExists(b));
  80.       assertTrue("Expected an IO exception", false);
  81.     } catch (IOException e) {
  82.       // ok - as expected
  83.     }
  84.     addSomeBlocks(fsdataset); // Only need to add one but ....
  85.     b = new Block(1, 0, 0);
  86.     InputStream metaInput = fsdataset.getMetaDataInputStream(b);
  87.     DataInputStream metaDataInput = new DataInputStream(metaInput);
  88.     short version = metaDataInput.readShort();
  89.     assertEquals(FSDataset.METADATA_VERSION, version);
  90.     DataChecksum checksum = DataChecksum.newDataChecksum(metaDataInput);
  91.     assertEquals(DataChecksum.CHECKSUM_NULL, checksum.getChecksumType());
  92.     assertEquals(0, checksum.getChecksumSize());  
  93.   }
  94.   public void testStorageUsage() throws IOException {
  95.     FSDatasetInterface fsdataset = new SimulatedFSDataset(conf); 
  96.     assertEquals(fsdataset.getDfsUsed(), 0);
  97.     assertEquals(fsdataset.getRemaining(), fsdataset.getCapacity());
  98.     int bytesAdded = addSomeBlocks(fsdataset);
  99.     assertEquals(bytesAdded, fsdataset.getDfsUsed());
  100.     assertEquals(fsdataset.getCapacity()-bytesAdded,  fsdataset.getRemaining());
  101.     
  102.   }
  103.   void  checkBlockDataAndSize(FSDatasetInterface fsdataset, 
  104.               Block b, long expectedLen) throws IOException { 
  105.     InputStream input = fsdataset.getBlockInputStream(b);
  106.     long lengthRead = 0;
  107.     int data;
  108.     while ((data = input.read()) != -1) {
  109.       assertEquals(SimulatedFSDataset.DEFAULT_DATABYTE, data);
  110.       lengthRead++;
  111.     }
  112.     assertEquals(expectedLen, lengthRead);
  113.   }
  114.   
  115.   public void testWriteRead() throws IOException {
  116.     FSDatasetInterface fsdataset = new SimulatedFSDataset(conf); 
  117.     addSomeBlocks(fsdataset);
  118.     for (int i=1; i <= NUMBLOCKS; ++i) {
  119.       Block b = new Block(i, 0, 0);
  120.       assertTrue(fsdataset.isValidBlock(b));
  121.       assertEquals(blockIdToLen(i), fsdataset.getLength(b));
  122.       checkBlockDataAndSize(fsdataset, b, blockIdToLen(i));
  123.     }
  124.   }
  125.   public void testGetBlockReport() throws IOException {
  126.     FSDatasetInterface fsdataset = new SimulatedFSDataset(conf); 
  127.     Block[] blockReport = fsdataset.getBlockReport();
  128.     assertEquals(0, blockReport.length);
  129.     int bytesAdded = addSomeBlocks(fsdataset);
  130.     blockReport = fsdataset.getBlockReport();
  131.     assertEquals(NUMBLOCKS, blockReport.length);
  132.     for (Block b: blockReport) {
  133.       assertNotNull(b);
  134.       assertEquals(blockIdToLen(b.getBlockId()), b.getNumBytes());
  135.     }
  136.   }
  137.   public void testInjectionEmpty() throws IOException {
  138.     FSDatasetInterface fsdataset = new SimulatedFSDataset(conf); 
  139.     Block[] blockReport = fsdataset.getBlockReport();
  140.     assertEquals(0, blockReport.length);
  141.     int bytesAdded = addSomeBlocks(fsdataset);
  142.     blockReport = fsdataset.getBlockReport();
  143.     assertEquals(NUMBLOCKS, blockReport.length);
  144.     for (Block b: blockReport) {
  145.       assertNotNull(b);
  146.       assertEquals(blockIdToLen(b.getBlockId()), b.getNumBytes());
  147.     }
  148.     
  149.     // Inject blocks into an empty fsdataset
  150.     //  - injecting the blocks we got above.
  151.   
  152.    
  153.     SimulatedFSDataset sfsdataset = new SimulatedFSDataset(conf);
  154.     sfsdataset.injectBlocks(blockReport);
  155.     blockReport = sfsdataset.getBlockReport();
  156.     assertEquals(NUMBLOCKS, blockReport.length);
  157.     for (Block b: blockReport) {
  158.       assertNotNull(b);
  159.       assertEquals(blockIdToLen(b.getBlockId()), b.getNumBytes());
  160.       assertEquals(blockIdToLen(b.getBlockId()), sfsdataset.getLength(b));
  161.     }
  162.     assertEquals(bytesAdded, sfsdataset.getDfsUsed());
  163.     assertEquals(sfsdataset.getCapacity()-bytesAdded, sfsdataset.getRemaining());
  164.   }
  165.   public void testInjectionNonEmpty() throws IOException {
  166.     FSDatasetInterface fsdataset = new SimulatedFSDataset(conf); 
  167.     
  168.     Block[] blockReport = fsdataset.getBlockReport();
  169.     assertEquals(0, blockReport.length);
  170.     int bytesAdded = addSomeBlocks(fsdataset);
  171.     blockReport = fsdataset.getBlockReport();
  172.     assertEquals(NUMBLOCKS, blockReport.length);
  173.     for (Block b: blockReport) {
  174.       assertNotNull(b);
  175.       assertEquals(blockIdToLen(b.getBlockId()), b.getNumBytes());
  176.     }
  177.     fsdataset = null;
  178.     
  179.     // Inject blocks into an non-empty fsdataset
  180.     //  - injecting the blocks we got above.
  181.   
  182.    
  183.     SimulatedFSDataset sfsdataset = new SimulatedFSDataset(conf);
  184.     // Add come blocks whose block ids do not conflict with
  185.     // the ones we are going to inject.
  186.     bytesAdded += addSomeBlocks(sfsdataset, NUMBLOCKS+1);
  187.     Block[] blockReport2 = sfsdataset.getBlockReport();
  188.     assertEquals(NUMBLOCKS, blockReport.length);
  189.     blockReport2 = sfsdataset.getBlockReport();
  190.     assertEquals(NUMBLOCKS, blockReport.length);
  191.     sfsdataset.injectBlocks(blockReport);
  192.     blockReport = sfsdataset.getBlockReport();
  193.     assertEquals(NUMBLOCKS*2, blockReport.length);
  194.     for (Block b: blockReport) {
  195.       assertNotNull(b);
  196.       assertEquals(blockIdToLen(b.getBlockId()), b.getNumBytes());
  197.       assertEquals(blockIdToLen(b.getBlockId()), sfsdataset.getLength(b));
  198.     }
  199.     assertEquals(bytesAdded, sfsdataset.getDfsUsed());
  200.     assertEquals(sfsdataset.getCapacity()-bytesAdded,  sfsdataset.getRemaining());
  201.     
  202.     
  203.     // Now test that the dataset cannot be created if it does not have sufficient cap
  204.     conf.setLong(SimulatedFSDataset.CONFIG_PROPERTY_CAPACITY, 10);
  205.  
  206.     try {
  207.       sfsdataset = new SimulatedFSDataset(conf);
  208.       sfsdataset.injectBlocks(blockReport);
  209.       assertTrue("Expected an IO exception", false);
  210.     } catch (IOException e) {
  211.       // ok - as expected
  212.     }
  213.   }
  214.   public void checkInvalidBlock(Block b) throws IOException {
  215.     FSDatasetInterface fsdataset = new SimulatedFSDataset(conf); 
  216.     assertFalse(fsdataset.isValidBlock(b));
  217.     try {
  218.       fsdataset.getLength(b);
  219.       assertTrue("Expected an IO exception", false);
  220.     } catch (IOException e) {
  221.       // ok - as expected
  222.     }
  223.     
  224.     try {
  225.       fsdataset.getBlockInputStream(b);
  226.       assertTrue("Expected an IO exception", false);
  227.     } catch (IOException e) {
  228.       // ok - as expected
  229.     }
  230.     
  231.     try {
  232.       fsdataset.finalizeBlock(b);
  233.       assertTrue("Expected an IO exception", false);
  234.     } catch (IOException e) {
  235.       // ok - as expected
  236.     }
  237.     
  238.   }
  239.   
  240.   public void testInValidBlocks() throws IOException {
  241.     FSDatasetInterface fsdataset = new SimulatedFSDataset(conf); 
  242.     Block b = new Block(1, 5, 0);
  243.     checkInvalidBlock(b);
  244.     
  245.     // Now check invlaid after adding some blocks
  246.     addSomeBlocks(fsdataset);
  247.     b = new Block(NUMBLOCKS + 99, 5, 0);
  248.     checkInvalidBlock(b);
  249.     
  250.   }
  251.   public void testInvalidate() throws IOException {
  252.     FSDatasetInterface fsdataset = new SimulatedFSDataset(conf); 
  253.     int bytesAdded = addSomeBlocks(fsdataset);
  254.     Block[] deleteBlocks = new Block[2];
  255.     deleteBlocks[0] = new Block(1, 0, 0);
  256.     deleteBlocks[1] = new Block(2, 0, 0);
  257.     fsdataset.invalidate(deleteBlocks);
  258.     checkInvalidBlock(deleteBlocks[0]);
  259.     checkInvalidBlock(deleteBlocks[1]);
  260.     long sizeDeleted = blockIdToLen(1) + blockIdToLen(2);
  261.     assertEquals(bytesAdded-sizeDeleted, fsdataset.getDfsUsed());
  262.     assertEquals(fsdataset.getCapacity()-bytesAdded+sizeDeleted,  fsdataset.getRemaining());
  263.     
  264.     
  265.     
  266.     // Now make sure the rest of the blocks are valid
  267.     for (int i=3; i <= NUMBLOCKS; ++i) {
  268.       Block b = new Block(i, 0, 0);
  269.       assertTrue(fsdataset.isValidBlock(b));
  270.     }
  271.   }
  272. }