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

网格计算

开发平台:

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 junit.framework.TestCase;
  20. import java.io.*;
  21. import java.net.*;
  22. import java.util.Random;
  23. import org.apache.hadoop.conf.Configuration;
  24. import org.apache.hadoop.fs.FsShell;
  25. import org.apache.hadoop.fs.FileSystem;
  26. import org.apache.hadoop.fs.Path;
  27. import org.apache.hadoop.util.StringUtils;
  28. import org.apache.hadoop.fs.FSDataOutputStream;
  29. import org.apache.hadoop.fs.FSDataInputStream;
  30. import org.apache.hadoop.hdfs.MiniDFSCluster;
  31. import org.apache.hadoop.hdfs.protocol.FSConstants.DatanodeReportType;
  32. import org.apache.hadoop.hdfs.server.datanode.SimulatedFSDataset;
  33. /**
  34.  * This class tests that a file system adheres to the limit of
  35.  * maximum number of files that is configured.
  36.  */
  37. public class TestFileLimit extends TestCase {
  38.   static final long seed = 0xDEADBEEFL;
  39.   static final int blockSize = 8192;
  40.   boolean simulatedStorage = false;
  41.   // The test file is 2 times the blocksize plus one. This means that when the
  42.   // entire file is written, the first two blocks definitely get flushed to
  43.   // the datanodes.
  44.   private static String TEST_ROOT_DIR =
  45.     new Path(System.getProperty("test.build.data","/tmp"))
  46.     .toString().replace(' ', '+');
  47.   
  48.   //
  49.   // creates a zero file.
  50.   //
  51.   private void createFile(FileSystem fileSys, Path name)
  52.     throws IOException {
  53.     FSDataOutputStream stm = fileSys.create(name, true,
  54.                                             fileSys.getConf().getInt("io.file.buffer.size", 4096),
  55.                                             (short)1, (long)blockSize);
  56.     byte[] buffer = new byte[1024];
  57.     Random rand = new Random(seed);
  58.     rand.nextBytes(buffer);
  59.     stm.write(buffer);
  60.     stm.close();
  61.   }
  62.   private void waitForLimit(FSNamesystem namesys, long num)
  63.   {
  64.     // wait for number of blocks to decrease
  65.     while (true) {
  66.       long total = namesys.getBlocksTotal() + namesys.dir.totalInodes();
  67.       System.out.println("Comparing current nodes " + total +
  68.                          " to become " + num);
  69.       if (total == num) {
  70.         break;
  71.       }
  72.       try {
  73.         Thread.sleep(1000);
  74.       } catch (InterruptedException e) {
  75.       }
  76.     }
  77.   }
  78.   /**
  79.    * Test that file data becomes available before file is closed.
  80.    */
  81.   public void testFileLimit() throws IOException {
  82.     Configuration conf = new Configuration();
  83.     int maxObjects = 5;
  84.     conf.setLong("dfs.max.objects", maxObjects);
  85.     conf.setLong("dfs.blockreport.intervalMsec", 1000L);
  86.     conf.setInt("dfs.heartbeat.interval", 1);
  87.     int currentNodes = 0;
  88.     
  89.     if (simulatedStorage) {
  90.       conf.setBoolean(SimulatedFSDataset.CONFIG_PROPERTY_SIMULATED, true);
  91.     }
  92.     MiniDFSCluster cluster = new MiniDFSCluster(conf, 1, true, null);
  93.     FileSystem fs = cluster.getFileSystem();
  94.     FSNamesystem namesys = FSNamesystem.fsNamesystemObject;
  95.     NameNode namenode = cluster.getNameNode();
  96.     try {
  97.       //
  98.       // check that / exists
  99.       //
  100.       Path path = new Path("/");
  101.       assertTrue("/ should be a directory", 
  102.                  fs.getFileStatus(path).isDir() == true);
  103.       currentNodes = 1;          // root inode
  104.       // verify that we can create the specified number of files. We leave
  105.       // one for the "/". Each file takes an inode and a block.
  106.       //
  107.       for (int i = 0; i < maxObjects/2; i++) {
  108.         Path file = new Path("/filestatus" + i);
  109.         createFile(fs, file);
  110.         System.out.println("Created file " + file);
  111.         currentNodes += 2;      // two more objects for this creation.
  112.       }
  113.       // verify that creating another file fails
  114.       boolean hitException = false;
  115.       try {
  116.         Path file = new Path("/filestatus");
  117.         createFile(fs, file);
  118.         System.out.println("Created file " + file);
  119.       } catch (IOException e) {
  120.         hitException = true;
  121.       }
  122.       assertTrue("Was able to exceed file limit", hitException);
  123.       // delete one file
  124.       Path file0 = new Path("/filestatus0");
  125.       fs.delete(file0, true);
  126.       System.out.println("Deleted file " + file0);
  127.       currentNodes -= 2;
  128.       // wait for number of blocks to decrease
  129.       waitForLimit(namesys, currentNodes);
  130.       // now, we shud be able to create a new file
  131.       createFile(fs, file0);
  132.       System.out.println("Created file " + file0 + " again.");
  133.       currentNodes += 2;
  134.       // delete the file again
  135.       file0 = new Path("/filestatus0");
  136.       fs.delete(file0, true);
  137.       System.out.println("Deleted file " + file0 + " again.");
  138.       currentNodes -= 2;
  139.       // wait for number of blocks to decrease
  140.       waitForLimit(namesys, currentNodes);
  141.       // create two directories in place of the file that we deleted
  142.       Path dir = new Path("/dir0/dir1");
  143.       fs.mkdirs(dir);
  144.       System.out.println("Created directories " + dir);
  145.       currentNodes += 2;
  146.       waitForLimit(namesys, currentNodes);
  147.       // verify that creating another directory fails
  148.       hitException = false;
  149.       try {
  150.         fs.mkdirs(new Path("dir.fail"));
  151.         System.out.println("Created directory should not have succeeded.");
  152.       } catch (IOException e) {
  153.         hitException = true;
  154.       }
  155.       assertTrue("Was able to exceed dir limit", hitException);
  156.     } finally {
  157.       fs.close();
  158.       cluster.shutdown();
  159.     }
  160.   }
  161.   public void testFileLimitSimulated() throws IOException {
  162.     simulatedStorage = true;
  163.     testFileLimit();
  164.     simulatedStorage = false;
  165.   }
  166. }