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

网格计算

开发平台:

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.fs;
  19. import java.io.File;
  20. import java.io.IOException;
  21. import org.apache.hadoop.conf.Configuration;
  22. import org.apache.hadoop.util.Shell;
  23. import junit.framework.TestCase;
  24. /** This test LocalDirAllocator works correctly;
  25.  * Every test case uses different buffer dirs to 
  26.  * enforce the AllocatorPerContext initialization.
  27.  * This test does not run on Cygwin because under Cygwin
  28.  * a directory can be created in a read-only directory
  29.  * which breaks this test.
  30.  */ 
  31. public class TestLocalDirAllocator extends TestCase {
  32.   final static private Configuration conf = new Configuration();
  33.   final static private String BUFFER_DIR_ROOT = "build/test/temp";
  34.   final static private Path BUFFER_PATH_ROOT = new Path(BUFFER_DIR_ROOT);
  35.   final static private File BUFFER_ROOT = new File(BUFFER_DIR_ROOT);
  36.   final static private String BUFFER_DIR[] = new String[] {
  37.     BUFFER_DIR_ROOT+"/tmp0",  BUFFER_DIR_ROOT+"/tmp1", BUFFER_DIR_ROOT+"/tmp2",
  38.     BUFFER_DIR_ROOT+"/tmp3", BUFFER_DIR_ROOT+"/tmp4", BUFFER_DIR_ROOT+"/tmp5",
  39.     BUFFER_DIR_ROOT+"/tmp6"};
  40.   final static private Path BUFFER_PATH[] = new Path[] {
  41.     new Path(BUFFER_DIR[0]), new Path(BUFFER_DIR[1]), new Path(BUFFER_DIR[2]),
  42.     new Path(BUFFER_DIR[3]), new Path(BUFFER_DIR[4]), new Path(BUFFER_DIR[5]),
  43.     new Path(BUFFER_DIR[6])};
  44.   final static private String CONTEXT = "dfs.client.buffer.dir";
  45.   final static private String FILENAME = "block";
  46.   final static private LocalDirAllocator dirAllocator = 
  47.     new LocalDirAllocator(CONTEXT);
  48.   static LocalFileSystem localFs;
  49.   final static private boolean isWindows =
  50.     System.getProperty("os.name").startsWith("Windows");
  51.   final static int SMALL_FILE_SIZE = 100;
  52.   static {
  53.     try {
  54.       localFs = FileSystem.getLocal(conf);
  55.       rmBufferDirs();
  56.     } catch(IOException e) {
  57.       System.out.println(e.getMessage());
  58.       e.printStackTrace();
  59.       System.exit(-1);
  60.     }
  61.   }
  62.   private static void rmBufferDirs() throws IOException {
  63.     assertTrue(!localFs.exists(BUFFER_PATH_ROOT) ||
  64.         localFs.delete(BUFFER_PATH_ROOT));
  65.   }
  66.   
  67.   private void validateTempDirCreation(int i) throws IOException {
  68.     File result = createTempFile(SMALL_FILE_SIZE);
  69.     assertTrue("Checking for " + BUFFER_DIR[i] + " in " + result + " - FAILED!", 
  70.         result.getPath().startsWith(new File(BUFFER_DIR[i], FILENAME).getPath()));
  71.   }
  72.   
  73.   private File createTempFile() throws IOException {
  74.     File result = dirAllocator.createTmpFileForWrite(FILENAME, -1, conf);
  75.     result.delete();
  76.     return result;
  77.   }
  78.   
  79.   private File createTempFile(long size) throws IOException {
  80.     File result = dirAllocator.createTmpFileForWrite(FILENAME, size, conf);
  81.     result.delete();
  82.     return result;
  83.   }
  84.   
  85.   /** Two buffer dirs. The first dir does not exist & is on a read-only disk; 
  86.    * The second dir exists & is RW
  87.    * @throws Exception
  88.    */
  89.   public void test0() throws Exception {
  90.     if (isWindows) return;
  91.     try {
  92.       conf.set(CONTEXT, BUFFER_DIR[0]+","+BUFFER_DIR[1]);
  93.       assertTrue(localFs.mkdirs(BUFFER_PATH[1]));
  94.       BUFFER_ROOT.setReadOnly();
  95.       validateTempDirCreation(1);
  96.       validateTempDirCreation(1);
  97.     } finally {
  98.       Shell.execCommand(new String[]{"chmod", "u+w", BUFFER_DIR_ROOT});
  99.       rmBufferDirs();
  100.     }
  101.   }
  102.     
  103.   /** Two buffer dirs. The first dir exists & is on a read-only disk; 
  104.    * The second dir exists & is RW
  105.    * @throws Exception
  106.    */
  107.   public void test1() throws Exception {
  108.     if (isWindows) return;
  109.     try {
  110.       conf.set(CONTEXT, BUFFER_DIR[1]+","+BUFFER_DIR[2]);
  111.       assertTrue(localFs.mkdirs(BUFFER_PATH[2]));
  112.       BUFFER_ROOT.setReadOnly();
  113.       validateTempDirCreation(2);
  114.       validateTempDirCreation(2);
  115.     } finally {
  116.       Shell.execCommand(new String[]{"chmod", "u+w", BUFFER_DIR_ROOT});
  117.       rmBufferDirs();
  118.     }
  119.   }
  120.   /** Two buffer dirs. Both do not exist but on a RW disk.
  121.    * Check if tmp dirs are allocated in a round-robin 
  122.    */
  123.   public void test2() throws Exception {
  124.     if (isWindows) return;
  125.     try {
  126.       conf.set(CONTEXT, BUFFER_DIR[2]+","+BUFFER_DIR[3]);
  127.       // create the first file, and then figure the round-robin sequence
  128.       createTempFile(SMALL_FILE_SIZE);
  129.       int firstDirIdx = (dirAllocator.getCurrentDirectoryIndex() == 0) ? 2 : 3;
  130.       int secondDirIdx = (firstDirIdx == 2) ? 3 : 2;
  131.       
  132.       // check if tmp dirs are allocated in a round-robin manner
  133.       validateTempDirCreation(firstDirIdx);
  134.       validateTempDirCreation(secondDirIdx);
  135.       validateTempDirCreation(firstDirIdx);
  136.     } finally {
  137.       rmBufferDirs();
  138.     }
  139.   }
  140.   /** Two buffer dirs. Both exists and on a R/W disk. 
  141.    * Later disk1 becomes read-only.
  142.    * @throws Exception
  143.    */
  144.   public void test3() throws Exception {
  145.     if (isWindows) return;
  146.     try {
  147.       conf.set(CONTEXT, BUFFER_DIR[3]+","+BUFFER_DIR[4]);
  148.       assertTrue(localFs.mkdirs(BUFFER_PATH[3]));
  149.       assertTrue(localFs.mkdirs(BUFFER_PATH[4]));
  150.       
  151.       // create the first file with size, and then figure the round-robin sequence
  152.       createTempFile(SMALL_FILE_SIZE);
  153.       int nextDirIdx = (dirAllocator.getCurrentDirectoryIndex() == 0) ? 3 : 4;
  154.       validateTempDirCreation(nextDirIdx);
  155.       // change buffer directory 2 to be read only
  156.       new File(BUFFER_DIR[4]).setReadOnly();
  157.       validateTempDirCreation(3);
  158.       validateTempDirCreation(3);
  159.     } finally {
  160.       rmBufferDirs();
  161.     }
  162.   }
  163.   
  164.   /**
  165.    * Two buffer dirs, on read-write disk.
  166.    * 
  167.    * Try to create a whole bunch of files.
  168.    *  Verify that they do indeed all get created where they should.
  169.    *  
  170.    *  Would ideally check statistical properties of distribution, but
  171.    *  we don't have the nerve to risk false-positives here.
  172.    * 
  173.    * @throws Exception
  174.    */
  175.   static final int TRIALS = 100;
  176.   public void test4() throws Exception {
  177.     if (isWindows) return;
  178.     try {
  179.       conf.set(CONTEXT, BUFFER_DIR[5]+","+BUFFER_DIR[6]);
  180.       assertTrue(localFs.mkdirs(BUFFER_PATH[5]));
  181.       assertTrue(localFs.mkdirs(BUFFER_PATH[6]));
  182.         
  183.       int inDir5=0, inDir6=0;
  184.       for(int i = 0; i < TRIALS; ++i) {
  185.         File result = createTempFile();
  186.         if(result.getPath().startsWith(new File(BUFFER_DIR[5], FILENAME).getPath())) {
  187.           inDir5++;
  188.         } else  if(result.getPath().startsWith(new File(BUFFER_DIR[6], FILENAME).getPath())) {
  189.           inDir6++;
  190.         }
  191.         result.delete();
  192.       }
  193.       
  194.       assertTrue( inDir5 + inDir6 == TRIALS);
  195.         
  196.     } finally {
  197.       rmBufferDirs();
  198.     }
  199.   }
  200.   
  201. }