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

网格计算

开发平台:

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;
  19. import java.io.BufferedReader;
  20. import java.io.ByteArrayOutputStream;
  21. import java.io.File;
  22. import java.io.FileReader;
  23. import java.io.IOException;
  24. import java.net.URL;
  25. import java.net.URLConnection;
  26. import java.util.Random;
  27. import junit.framework.TestCase;
  28. import org.apache.hadoop.hdfs.DFSClient.DFSDataInputStream;
  29. import org.apache.hadoop.hdfs.protocol.Block;
  30. import org.apache.hadoop.io.IOUtils;
  31. import org.apache.hadoop.fs.FSDataInputStream;
  32. import org.apache.hadoop.fs.FSDataOutputStream;
  33. import org.apache.hadoop.fs.FileSystem;
  34. import org.apache.hadoop.fs.Path;
  35. import org.apache.hadoop.fs.BlockLocation;
  36. /**
  37.  */
  38. public class DFSTestUtil extends TestCase {
  39.   
  40.   private static Random gen = new Random();
  41.   private static String[] dirNames = {
  42.     "zero", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine"
  43.   };
  44.   
  45.   private int maxLevels;// = 3;
  46.   private int maxSize;// = 8*1024;
  47.   private int nFiles;
  48.   private MyFile[] files;
  49.   
  50.   /** Creates a new instance of DFSTestUtil
  51.    *
  52.    * @param testName Name of the test from where this utility is used
  53.    * @param nFiles Number of files to be created
  54.    * @param maxLevels Maximum number of directory levels
  55.    * @param maxSize Maximum size for file
  56.    */
  57.   public DFSTestUtil(String testName, int nFiles, int maxLevels, int maxSize) {
  58.     this.nFiles = nFiles;
  59.     this.maxLevels = maxLevels;
  60.     this.maxSize = maxSize;
  61.   }
  62.   
  63.   /** class MyFile contains enough information to recreate the contents of
  64.    * a single file.
  65.    */
  66.   private class MyFile {
  67.     
  68.     private String name = "";
  69.     private int size;
  70.     private long seed;
  71.     
  72.     MyFile() {
  73.       int nLevels = gen.nextInt(maxLevels);
  74.       if (nLevels != 0) {
  75.         int[] levels = new int[nLevels];
  76.         for (int idx = 0; idx < nLevels; idx++) {
  77.           levels[idx] = gen.nextInt(10);
  78.         }
  79.         StringBuffer sb = new StringBuffer();
  80.         for (int idx = 0; idx < nLevels; idx++) {
  81.           sb.append(dirNames[levels[idx]]);
  82.           sb.append("/");
  83.         }
  84.         name = sb.toString();
  85.       }
  86.       long fidx = -1;
  87.       while (fidx < 0) { fidx = gen.nextLong(); }
  88.       name = name + Long.toString(fidx);
  89.       size = gen.nextInt(maxSize);
  90.       seed = gen.nextLong();
  91.     }
  92.     
  93.     String getName() { return name; }
  94.     int getSize() { return size; }
  95.     long getSeed() { return seed; }
  96.   }
  97.   public void createFiles(FileSystem fs, String topdir) throws IOException {
  98.     createFiles(fs, topdir, (short)3);
  99.   }
  100.   
  101.   /** create nFiles with random names and directory hierarchies
  102.    *  with random (but reproducible) data in them.
  103.    */
  104.   void createFiles(FileSystem fs, String topdir,
  105.                    short replicationFactor) throws IOException {
  106.     files = new MyFile[nFiles];
  107.     
  108.     for (int idx = 0; idx < nFiles; idx++) {
  109.       files[idx] = new MyFile();
  110.     }
  111.     
  112.     Path root = new Path(topdir);
  113.     
  114.     for (int idx = 0; idx < nFiles; idx++) {
  115.       createFile(fs, new Path(root, files[idx].getName()), files[idx].getSize(),
  116.           replicationFactor, files[idx].getSeed());
  117.     }
  118.   }
  119.   
  120.   public static void createFile(FileSystem fs, Path fileName, long fileLen, 
  121.       short replFactor, long seed) throws IOException {
  122.     if (!fs.mkdirs(fileName.getParent())) {
  123.       throw new IOException("Mkdirs failed to create " + 
  124.                             fileName.getParent().toString());
  125.     }
  126.     FSDataOutputStream out = null;
  127.     try {
  128.       out = fs.create(fileName, replFactor);
  129.       byte[] toWrite = new byte[1024];
  130.       Random rb = new Random(seed);
  131.       long bytesToWrite = fileLen;
  132.       while (bytesToWrite>0) {
  133.         rb.nextBytes(toWrite);
  134.         int bytesToWriteNext = (1024<bytesToWrite)?1024:(int)bytesToWrite;
  135.         out.write(toWrite, 0, bytesToWriteNext);
  136.         bytesToWrite -= bytesToWriteNext;
  137.       }
  138.       out.close();
  139.       out = null;
  140.     } finally {
  141.       IOUtils.closeStream(out);
  142.     }
  143.   }
  144.   
  145.   /** check if the files have been copied correctly. */
  146.   public boolean checkFiles(FileSystem fs, String topdir) throws IOException {
  147.     
  148.     //Configuration conf = new Configuration();
  149.     Path root = new Path(topdir);
  150.     
  151.     for (int idx = 0; idx < nFiles; idx++) {
  152.       Path fPath = new Path(root, files[idx].getName());
  153.       FSDataInputStream in = fs.open(fPath);
  154.       byte[] toRead = new byte[files[idx].getSize()];
  155.       byte[] toCompare = new byte[files[idx].getSize()];
  156.       Random rb = new Random(files[idx].getSeed());
  157.       rb.nextBytes(toCompare);
  158.       in.readFully(0, toRead);
  159.       in.close();
  160.       for (int i = 0; i < toRead.length; i++) {
  161.         if (toRead[i] != toCompare[i]) {
  162.           return false;
  163.         }
  164.       }
  165.       toRead = null;
  166.       toCompare = null;
  167.     }
  168.     
  169.     return true;
  170.   }
  171.   void setReplication(FileSystem fs, String topdir, short value) 
  172.                                               throws IOException {
  173.     Path root = new Path(topdir);
  174.     for (int idx = 0; idx < nFiles; idx++) {
  175.       Path fPath = new Path(root, files[idx].getName());
  176.       fs.setReplication(fPath, value);
  177.     }
  178.   }
  179.   // waits for the replication factor of all files to reach the
  180.   // specified target
  181.   //
  182.   public void waitReplication(FileSystem fs, String topdir, short value) 
  183.                                               throws IOException {
  184.     Path root = new Path(topdir);
  185.     /** wait for the replication factor to settle down */
  186.     for (int idx = 0; idx < nFiles; idx++) {
  187.       waitReplication(fs, new Path(root, files[idx].getName()), value);
  188.     }
  189.   }
  190.   /** return list of filenames created as part of createFiles */
  191.   public String[] getFileNames(String topDir) {
  192.     if (nFiles == 0)
  193.       return new String[]{};
  194.     else {
  195.       String[] fileNames =  new String[nFiles];
  196.       for (int idx=0; idx < nFiles; idx++) {
  197.         fileNames[idx] = topDir + "/" + files[idx].getName();
  198.       }
  199.       return fileNames;
  200.     }
  201.   }
  202.   
  203.   /** wait for the file's replication to be done */
  204.   public static void waitReplication(FileSystem fs, Path fileName, 
  205.       short replFactor)  throws IOException {
  206.     boolean good;
  207.     do {
  208.       good = true;
  209.       BlockLocation locs[] = fs.getFileBlockLocations(
  210.         fs.getFileStatus(fileName), 0, Long.MAX_VALUE);
  211.       for (int j = 0; j < locs.length; j++) {
  212.         String[] loc = locs[j].getHosts();
  213.         if (loc.length != replFactor) {
  214.           System.out.println("File " + fileName + " has replication factor " +
  215.               loc.length);
  216.           good = false;
  217.           try {
  218.             System.out.println("Waiting for replication factor to drain");
  219.             Thread.sleep(100);
  220.           } catch (InterruptedException e) {} 
  221.           break;
  222.         }
  223.       }
  224.     } while(!good);
  225.   }
  226.   
  227.   /** delete directory and everything underneath it.*/
  228.   public void cleanup(FileSystem fs, String topdir) throws IOException {
  229.     Path root = new Path(topdir);
  230.     fs.delete(root, true);
  231.     files = null;
  232.   }
  233.   
  234.   public static Block getFirstBlock(FileSystem fs, Path path) throws IOException {
  235.     DFSDataInputStream in = 
  236.       (DFSDataInputStream) ((DistributedFileSystem)fs).open(path);
  237.     in.readByte();
  238.     return in.getCurrentBlock();
  239.   }  
  240.   static void setLogLevel2All(org.apache.commons.logging.Log log) {
  241.     ((org.apache.commons.logging.impl.Log4JLogger)log
  242.         ).getLogger().setLevel(org.apache.log4j.Level.ALL);
  243.   }
  244.   static String readFile(File f) throws IOException {
  245.     StringBuilder b = new StringBuilder();
  246.     BufferedReader in = new BufferedReader(new FileReader(f));
  247.     for(int c; (c = in.read()) != -1; b.append((char)c));
  248.     in.close();      
  249.     return b.toString();
  250.   }
  251.   // Returns url content as string.
  252.   public static String urlGet(URL url) throws IOException {
  253.     URLConnection conn = url.openConnection();
  254.     ByteArrayOutputStream out = new ByteArrayOutputStream();
  255.     IOUtils.copyBytes(conn.getInputStream(), out, 4096, true);
  256.     return out.toString();
  257.   }
  258. }