TestModTime.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;
  19. import junit.framework.TestCase;
  20. import java.io.*;
  21. import java.util.Random;
  22. import java.net.*;
  23. import org.apache.hadoop.conf.Configuration;
  24. import org.apache.hadoop.hdfs.protocol.DatanodeInfo;
  25. import org.apache.hadoop.hdfs.protocol.FSConstants.DatanodeReportType;
  26. import org.apache.hadoop.fs.FSDataOutputStream;
  27. import org.apache.hadoop.fs.FileSystem;
  28. import org.apache.hadoop.fs.Path;
  29. import org.apache.hadoop.fs.FileStatus;
  30. /**
  31.  * This class tests the decommissioning of nodes.
  32.  * @author Dhruba Borthakur
  33.  */
  34. public class TestModTime extends TestCase {
  35.   static final long seed = 0xDEADBEEFL;
  36.   static final int blockSize = 8192;
  37.   static final int fileSize = 16384;
  38.   static final int numDatanodes = 6;
  39.   Random myrand = new Random();
  40.   Path hostsFile;
  41.   Path excludeFile;
  42.   private void writeFile(FileSystem fileSys, Path name, int repl)
  43.     throws IOException {
  44.     // create and write a file that contains three blocks of data
  45.     FSDataOutputStream stm = fileSys.create(name, true, 
  46.                                             fileSys.getConf().getInt("io.file.buffer.size", 4096),
  47.                                             (short)repl, (long)blockSize);
  48.     byte[] buffer = new byte[fileSize];
  49.     Random rand = new Random(seed);
  50.     rand.nextBytes(buffer);
  51.     stm.write(buffer);
  52.     stm.close();
  53.   }
  54.   
  55.   private void cleanupFile(FileSystem fileSys, Path name) throws IOException {
  56.     assertTrue(fileSys.exists(name));
  57.     fileSys.delete(name, true);
  58.     assertTrue(!fileSys.exists(name));
  59.   }
  60.   private void printDatanodeReport(DatanodeInfo[] info) {
  61.     System.out.println("-------------------------------------------------");
  62.     for (int i = 0; i < info.length; i++) {
  63.       System.out.println(info[i].getDatanodeReport());
  64.       System.out.println();
  65.     }
  66.   }
  67.   /**
  68.    * Tests modification time in DFS.
  69.    */
  70.   public void testModTime() throws IOException {
  71.     Configuration conf = new Configuration();
  72.     MiniDFSCluster cluster = new MiniDFSCluster(conf, numDatanodes, true, null);
  73.     cluster.waitActive();
  74.     InetSocketAddress addr = new InetSocketAddress("localhost", 
  75.                                                    cluster.getNameNodePort());
  76.     DFSClient client = new DFSClient(addr, conf);
  77.     DatanodeInfo[] info = client.datanodeReport(DatanodeReportType.LIVE);
  78.     assertEquals("Number of Datanodes ", numDatanodes, info.length);
  79.     FileSystem fileSys = cluster.getFileSystem();
  80.     int replicas = numDatanodes - 1;
  81.     assertTrue(fileSys instanceof DistributedFileSystem);
  82.     try {
  83.      //
  84.      // create file and record ctime and mtime of test file
  85.      //
  86.      System.out.println("Creating testdir1 and testdir1/test1.dat.");
  87.      Path dir1 = new Path("testdir1");
  88.      Path file1 = new Path(dir1, "test1.dat");
  89.      writeFile(fileSys, file1, replicas);
  90.      FileStatus stat = fileSys.getFileStatus(file1);
  91.      long mtime1 = stat.getModificationTime();
  92.      assertTrue(mtime1 != 0);
  93.      //
  94.      // record dir times
  95.      //
  96.      stat = fileSys.getFileStatus(dir1);
  97.      long mdir1 = stat.getModificationTime();
  98.      //
  99.      // create second test file
  100.      //
  101.      System.out.println("Creating testdir1/test2.dat.");
  102.      Path file2 = new Path(dir1, "test2.dat");
  103.      writeFile(fileSys, file2, replicas);
  104.      stat = fileSys.getFileStatus(file2);
  105.      //
  106.      // verify that mod time of dir remains the same
  107.      // as before. modification time of directory has increased.
  108.      //
  109.      stat = fileSys.getFileStatus(dir1);
  110.      assertTrue(stat.getModificationTime() >= mdir1);
  111.      mdir1 = stat.getModificationTime();
  112.      //
  113.      // create another directory
  114.      //
  115.      Path dir2 = (new Path("testdir2/")).makeQualified(fileSys);
  116.      System.out.println("Creating testdir2 " + dir2);
  117.      assertTrue(fileSys.mkdirs(dir2));
  118.      stat = fileSys.getFileStatus(dir2);
  119.      long mdir2 = stat.getModificationTime();
  120.      //
  121.      // rename file1 from testdir into testdir2
  122.      //
  123.      Path newfile = new Path(dir2, "testnew.dat");
  124.      System.out.println("Moving " + file1 + " to " + newfile);
  125.      fileSys.rename(file1, newfile);
  126.      //
  127.      // verify that modification time of file1 did not change.
  128.      //
  129.      stat = fileSys.getFileStatus(newfile);
  130.      assertTrue(stat.getModificationTime() == mtime1);
  131.      //
  132.      // verify that modification time of  testdir1 and testdir2
  133.      // were changed. 
  134.      //
  135.      stat = fileSys.getFileStatus(dir1);
  136.      assertTrue(stat.getModificationTime() != mdir1);
  137.      mdir1 = stat.getModificationTime();
  138.      stat = fileSys.getFileStatus(dir2);
  139.      assertTrue(stat.getModificationTime() != mdir2);
  140.      mdir2 = stat.getModificationTime();
  141.      //
  142.      // delete newfile
  143.      //
  144.      System.out.println("Deleting testdir2/testnew.dat.");
  145.      assertTrue(fileSys.delete(newfile, true));
  146.      //
  147.      // verify that modification time of testdir1 has not changed.
  148.      //
  149.      stat = fileSys.getFileStatus(dir1);
  150.      assertTrue(stat.getModificationTime() == mdir1);
  151.      //
  152.      // verify that modification time of testdir2 has changed.
  153.      //
  154.      stat = fileSys.getFileStatus(dir2);
  155.      assertTrue(stat.getModificationTime() != mdir2);
  156.      mdir2 = stat.getModificationTime();
  157.      cleanupFile(fileSys, file2);
  158.      cleanupFile(fileSys, dir1);
  159.      cleanupFile(fileSys, dir2);
  160.     } catch (IOException e) {
  161.       info = client.datanodeReport(DatanodeReportType.ALL);
  162.       printDatanodeReport(info);
  163.       throw e;
  164.     } finally {
  165.       fileSys.close();
  166.       cluster.shutdown();
  167.     }
  168.   }
  169.   public static void main(String[] args) throws Exception {
  170.     new TestModTime().testModTime();
  171.   }
  172. }