HadoopTestCase.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.mapred;
  19. import junit.framework.TestCase;
  20. import org.apache.hadoop.hdfs.MiniDFSCluster;
  21. import org.apache.hadoop.fs.FileSystem;
  22. import org.apache.hadoop.fs.Path;
  23. import java.io.File;
  24. import java.io.IOException;
  25. /**
  26.  * Abstract Test case class to run MR in local or cluster mode and in local FS
  27.  * or DFS.
  28.  *
  29.  * The Hadoop instance is started and stopped on each test method.
  30.  *
  31.  * If using DFS the filesystem is reformated at each start (test method).
  32.  *
  33.  * Job Configurations should be created using a configuration returned by the
  34.  * 'createJobConf()' method.
  35.  */
  36. public abstract class HadoopTestCase extends TestCase {
  37.   public static final int LOCAL_MR = 1;
  38.   public static final int CLUSTER_MR = 2;
  39.   public static final int LOCAL_FS = 4;
  40.   public static final int DFS_FS = 8;
  41.   private boolean localMR;
  42.   private boolean localFS;
  43.   private int taskTrackers;
  44.   private int dataNodes;
  45.   /**
  46.    * Creates a testcase for local or cluster MR using DFS.
  47.    *
  48.    * The DFS will be formatted regardless if there was one or not before in the
  49.    * given location.
  50.    *
  51.    * @param mrMode indicates if the MR should be local (LOCAL_MR) or cluster
  52.    * (CLUSTER_MR)
  53.    * @param fsMode indicates if the FS should be local (LOCAL_FS) or DFS (DFS_FS)
  54.    *
  55.    * local FS when using relative PATHs)
  56.    *
  57.    * @param taskTrackers number of task trackers to start when using cluster
  58.    *
  59.    * @param dataNodes number of data nodes to start when using DFS
  60.    *
  61.    * @throws IOException thrown if the base directory cannot be set.
  62.    */
  63.   public HadoopTestCase(int mrMode, int fsMode, int taskTrackers, int dataNodes)
  64.     throws IOException {
  65.     if (mrMode != LOCAL_MR && mrMode != CLUSTER_MR) {
  66.       throw new IllegalArgumentException(
  67.                                          "Invalid MapRed mode, must be LOCAL_MR or CLUSTER_MR");
  68.     }
  69.     if (fsMode != LOCAL_FS && fsMode != DFS_FS) {
  70.       throw new IllegalArgumentException(
  71.                                          "Invalid FileSystem mode, must be LOCAL_FS or DFS_FS");
  72.     }
  73.     if (taskTrackers < 1) {
  74.       throw new IllegalArgumentException(
  75.                                          "Invalid taskTrackers value, must be greater than 0");
  76.     }
  77.     if (dataNodes < 1) {
  78.       throw new IllegalArgumentException(
  79.                                          "Invalid dataNodes value, must be greater than 0");
  80.     }
  81.     localMR = (mrMode == LOCAL_MR);
  82.     localFS = (fsMode == LOCAL_FS);
  83.     /*
  84.       JobConf conf = new JobConf();
  85.       fsRoot = conf.get("hadoop.tmp.dir");
  86.       if (fsRoot == null) {
  87.       throw new IllegalArgumentException(
  88.       "hadoop.tmp.dir is not defined");
  89.       }
  90.       fsRoot = fsRoot.replace(' ', '+') + "/fs";
  91.       File file = new File(fsRoot);
  92.       if (!file.exists()) {
  93.       if (!file.mkdirs()) {
  94.       throw new RuntimeException("Could not create FS base path: " + file);
  95.       }
  96.       }
  97.     */
  98.     this.taskTrackers = taskTrackers;
  99.     this.dataNodes = dataNodes;
  100.   }
  101.   /**
  102.    * Indicates if the MR is running in local or cluster mode.
  103.    *
  104.    * @return returns TRUE if the MR is running locally, FALSE if running in
  105.    * cluster mode.
  106.    */
  107.   public boolean isLocalMR() {
  108.     return localMR;
  109.   }
  110.   /**
  111.    * Indicates if the filesystem is local or DFS.
  112.    *
  113.    * @return returns TRUE if the filesystem is local, FALSE if it is DFS.
  114.    */
  115.   public boolean isLocalFS() {
  116.     return localFS;
  117.   }
  118.   private MiniDFSCluster dfsCluster = null;
  119.   private MiniMRCluster mrCluster = null;
  120.   private FileSystem fileSystem = null;
  121.   /**
  122.    * Creates Hadoop instance based on constructor configuration before
  123.    * a test case is run.
  124.    *
  125.    * @throws Exception
  126.    */
  127.   protected void setUp() throws Exception {
  128.     super.setUp();
  129.     if (localFS) {
  130.       fileSystem = FileSystem.getLocal(new JobConf());
  131.     }
  132.     else {
  133.       dfsCluster = new MiniDFSCluster(new JobConf(), dataNodes, true, null);
  134.       fileSystem = dfsCluster.getFileSystem();
  135.     }
  136.     if (localMR) {
  137.     }
  138.     else {
  139.       //noinspection deprecation
  140.       mrCluster = new MiniMRCluster(taskTrackers, fileSystem.getName(), 1);
  141.     }
  142.   }
  143.   /**
  144.    * Destroys Hadoop instance based on constructor configuration after
  145.    * a test case is run.
  146.    *
  147.    * @throws Exception
  148.    */
  149.   protected void tearDown() throws Exception {
  150.     try {
  151.       if (mrCluster != null) {
  152.         mrCluster.shutdown();
  153.       }
  154.     }
  155.     catch (Exception ex) {
  156.       System.out.println(ex);
  157.     }
  158.     try {
  159.       if (dfsCluster != null) {
  160.         dfsCluster.shutdown();
  161.       }
  162.     }
  163.     catch (Exception ex) {
  164.       System.out.println(ex);
  165.     }
  166.     super.tearDown();
  167.   }
  168.   /**
  169.    * Returns the Filesystem in use.
  170.    *
  171.    * TestCases should use this Filesystem as it
  172.    * is properly configured with the workingDir for relative PATHs.
  173.    *
  174.    * @return the filesystem used by Hadoop.
  175.    */
  176.   protected FileSystem getFileSystem() {
  177.     return fileSystem;
  178.   }
  179.   /**
  180.    * Returns a job configuration preconfigured to run against the Hadoop
  181.    * managed by the testcase.
  182.    * @return configuration that works on the testcase Hadoop instance
  183.    */
  184.   protected JobConf createJobConf() {
  185.     return (localMR) ? new JobConf() : mrCluster.createJobConf();
  186.   }
  187. }