* Copyright 2009 The Apache Software Foundation

*

* Licensed to the Apache Software Foundation (ASF) under one

* or more contributor license agreements.  See the NOTICE file

* distributed with this work for additional information

* regarding copyright ownership.  The ASF licenses this file

* to you under the Apache License, Version 2.0 (the

* "License"); you may not use this file except in compliance

* with the License.  You may obtain a copy of the License at

*

*     http://www.apache.org/licenses/LICENSE-2.0

*

* Unless required by applicable law or agreed to in writing, software

* distributed under the License is distributed on an "AS IS" BASIS,

* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

* See the License for the specific language governing permissions and

* limitations under the License.

*/

* Facility for testing HBase. Replacement for

* old HBaseTestCase and HBaseClusterTestCase functionality.

* Create an instance and keep it around testing HBase.  This class is

* meant to be your one-stop shop for anything you might need testing.  Manages

* one cluster at a time only. Managed cluster can be an in-process

* {@link MiniHBaseCluster}, or a deployed cluster of type {@link DistributedHBaseCluster}.

* Not all methods work with the real cluster.

* Depends on log4j being on classpath and

* hbase-site.xml for logging and test-run configuration.  It does not set

* logging levels nor make changes to configuration parameters.

*/

  private static final Log LOG = LogFactory.getLog(HBaseTestingUtility.class);

  private Configuration conf;

  private MiniZooKeeperCluster zkCluster = null;

  /**

   * The default number of regions per regionserver when creating a pre-split

   * table.

   */

  private static int DEFAULT_REGIONS_PER_SERVER = 5;

  /**

   * Set if we were passed a zkCluster.  If so, we won't shutdown zk as

   * part of general shutdown.

   */

  private boolean passedZkCluster = false;

  private MiniDFSCluster dfsCluster = null;

  private HBaseCluster hbaseCluster = null;

  private MiniMRCluster mrCluster = null;

  // Directory where we put the data for this instance of HBaseTestingUtility

  private File dataTestDir = null;

  // Directory (usually a subdirectory of dataTestDir) used by the dfs cluster

  //  if any

  private File clusterTestDir = null;

  /**

   * System property key to get test directory value.

   * Name is as it is because mini dfs has hard-codings to put test data here.

   * It should NOT be used directly in HBase, as it's a property used in

   *  mini dfs.

   *  @deprecated can be used only with mini dfs

   */

  private static final String TEST_DIRECTORY_KEY = "test.build.data";

  /**

   * System property key to get base test directory value

   */

  public static final String BASE_TEST_DIRECTORY_KEY =

    "test.build.data.basedirectory";

  /**

   * Default base directory for test output.

   */

  public static final String DEFAULT_BASE_TEST_DIRECTORY = "target/test-data";

  /** Compression algorithms to use in parameterized JUnit 4 tests */

  public static final List<Object[]> COMPRESSION_ALGORITHMS_PARAMETERIZED =

    Arrays.asList(new Object[][] {

      { Compression.Algorithm.NONE },

      { Compression.Algorithm.GZ }

    });

  /** This is for unit tests parameterized with a single boolean. */

  public static final List<Object[]> BOOLEAN_PARAMETERIZED =

      Arrays.asList(new Object[][] {

          { new Boolean(false) },

          { new Boolean(true) }

      });

  /** Compression algorithms to use in testing */

  public static final Compression.Algorithm[] COMPRESSION_ALGORITHMS ={

      Compression.Algorithm.NONE, Compression.Algorithm.GZ

    };

  /**

   * Create all combinations of Bloom filters and compression algorithms for

   * testing.

   */

  private static List<Object[]> bloomAndCompressionCombinations() {

    List<Object[]> configurations = new ArrayList<Object[]>();

    for (Compression.Algorithm comprAlgo :

         HBaseTestingUtility.COMPRESSION_ALGORITHMS) {

      for (StoreFile.BloomType bloomType : StoreFile.BloomType.values()) {

        configurations.add(new Object[] { comprAlgo, bloomType });

      }

    }

    return Collections.unmodifiableList(configurations);

  }

  public static final Collection<Object[]> BLOOM_AND_COMPRESSION_COMBINATIONS =

      bloomAndCompressionCombinations();

  public HBaseTestingUtility() {

    this(HBaseConfiguration.create());

  }

  public HBaseTestingUtility(Configuration conf) {

    this.conf = conf;

    // a hbase checksum verification failure will cause unit tests to fail

    ChecksumUtil.generateExceptionForChecksumFailureForTest(true);

    setHDFSClientRetryProperty();

  }

  private void setHDFSClientRetryProperty() {

    this.conf.setInt("hdfs.client.retries.number", 1);

    HBaseFileSystem.setRetryCounts(conf);

  }

  /**

   * Returns this classes's instance of {@link Configuration}.  Be careful how

   * you use the returned Configuration since {@link HConnection} instances

   * can be shared.  The Map of HConnections is keyed by the Configuration.  If

   * say, a Connection was being used against a cluster that had been shutdown,

   * see {@link #shutdownMiniCluster()}, then the Connection will no longer

   * be wholesome.  Rather than use the return direct, its usually best to

   * make a copy and use that.  Do

   * <code>Configuration c = new Configuration(INSTANCE.getConfiguration());</code>

   * @return Instance of Configuration.

   */

  public Configuration getConfiguration() {

    return this.conf;

  }

  public void setHBaseCluster(HBaseCluster hbaseCluster) {

    this.hbaseCluster = hbaseCluster;

  }

  /**

   * @return Where to write test data on local filesystem; usually

   * {@link #DEFAULT_BASE_TEST_DIRECTORY}

   * Should not be used by the unit tests, hence its's private.

   * Unit test will use a subdirectory of this directory.

   * @see #setupDataTestDir()

   * @see #getTestFileSystem()

   */

  private Path getBaseTestDir() {

    String PathName = System.getProperty(

      BASE_TEST_DIRECTORY_KEY, DEFAULT_BASE_TEST_DIRECTORY);

    return new Path(PathName);

  }

  /**

   * @return Where to write test data on local filesystem, specific to

   *  the test.  Useful for tests that do not use a cluster.

   * Creates it if it does not exist already.

   * @see #getTestFileSystem()

   */

  public Path getDataTestDir() {

    if (dataTestDir == null){

      setupDataTestDir();

    }

    return new Path(dataTestDir.getAbsolutePath());

  }

  /**

   * @return Where the DFS cluster will write data on the local subsystem.

   * Creates it if it does not exist already.

   * @see #getTestFileSystem()

   */

  public Path getClusterTestDir() {

    if (clusterTestDir == null){

      setupClusterTestDir();

    }

    return new Path(clusterTestDir.getAbsolutePath());

  }

  /**

   * @param subdirName

   * @return Path to a subdirectory named <code>subdirName</code> under

   * {@link #getDataTestDir()}.

   * Does *NOT* create it if it does not exist.

   */

  public Path getDataTestDir(final String subdirName) {

    return new Path(getDataTestDir(), subdirName);

  }

  /**

   * Home our data in a dir under {@link #DEFAULT_BASE_TEST_DIRECTORY}.

   * Give it a random name so can have many concurrent tests running if

   * we need to.  It needs to amend the {@link #TEST_DIRECTORY_KEY}

   * System property, as it's what minidfscluster bases

   * it data dir on.  Moding a System property is not the way to do concurrent

   * instances -- another instance could grab the temporary

   * value unintentionally -- but not anything can do about it at moment;

   * single instance only is how the minidfscluster works.

   *

   * We also create the underlying directory for

   *  hadoop.log.dir, mapred.local.dir and hadoop.tmp.dir, and set the values

   *  in the conf, and as a system property for hadoop.tmp.dir

   *

   * @return The calculated data test build directory.

   */

  private void setupDataTestDir() {

    if (dataTestDir != null) {

      LOG.warn("Data test dir already setup in " +

        dataTestDir.getAbsolutePath());

      return;

    }

    String randomStr = UUID.randomUUID().toString();

    Path testPath= new Path(getBaseTestDir(), randomStr);

    dataTestDir = new File(testPath.toString()).getAbsoluteFile();

    dataTestDir.deleteOnExit();

    createSubDirAndSystemProperty(

      "hadoop.log.dir",

      testPath, "hadoop-log-dir");

    // This is defaulted in core-default.xml to /tmp/hadoop-${user.name}, but

    //  we want our own value to ensure uniqueness on the same machine

    createSubDirAndSystemProperty(

      "hadoop.tmp.dir",

      testPath, "hadoop-tmp-dir");

    // Read and modified in org.apache.hadoop.mapred.MiniMRCluster

    createSubDir(

      "mapred.local.dir",

      testPath, "mapred-local-dir");

    createSubDirAndSystemProperty(

      "mapred.working.dir",

      testPath, "mapred-working-dir");

    createSubDir(

      "hbase.local.dir",

      testPath, "hbase-local-dir");

  }

  private void createSubDir(String propertyName, Path parent, String subDirName){

    Path newPath= new Path(parent, subDirName);

    File newDir = new File(newPath.toString()).getAbsoluteFile();

    newDir.deleteOnExit();

    conf.set(propertyName, newDir.getAbsolutePath());

  }

  private void createSubDirAndSystemProperty(

    String propertyName, Path parent, String subDirName){

    String sysValue = System.getProperty(propertyName);

    if (sysValue != null) {

      // There is already a value set. So we do nothing but hope

      //  that there will be no conflicts

      LOG.info("System.getProperty(\""+propertyName+"\") already set to: "+

        sysValue + " so I do NOT create it in "+dataTestDir.getAbsolutePath());

      String confValue = conf.get(propertyName);

      if (confValue != null && !confValue.endsWith(sysValue)){

       LOG.warn(

         propertyName + " property value differs in configuration and system: "+

         "Configuration="+confValue+" while System="+sysValue+

         " Erasing configuration value by system value."

       );

      }

      conf.set(propertyName, sysValue);

    } else {

      // Ok, it's not set, so we create it as a subdirectory

      createSubDir(propertyName, parent, subDirName);

      System.setProperty(propertyName, conf.get(propertyName));

    }

  }

  /**

   * Creates a directory for the DFS cluster, under the test data

   */

  private void setupClusterTestDir() {

    if (clusterTestDir != null) {

      LOG.warn("Cluster test dir already setup in " +

        clusterTestDir.getAbsolutePath());

      return;

    }

    // Using randomUUID ensures that multiple clusters can be launched by

    //  a same test, if it stops & starts them

    Path testDir = getDataTestDir("dfscluster_" + UUID.randomUUID().toString());

    clusterTestDir = new File(testDir.toString()).getAbsoluteFile();

    // Have it cleaned up on exit

    clusterTestDir.deleteOnExit();

  }

  /**

   * @throws IOException If a cluster -- zk, dfs, or hbase -- already running.

   */

  public void isRunningCluster() throws IOException {

    if (dfsCluster == null) return;

    throw new IOException("Cluster already running at " +

      this.clusterTestDir);

  }

  /**

   * Start a minidfscluster.

   * @param servers How many DNs to start.

   * @throws Exception

   * @see {@link #shutdownMiniDFSCluster()}

   * @return The mini dfs cluster created.

   */

  public MiniDFSCluster startMiniDFSCluster(int servers) throws Exception {

    return startMiniDFSCluster(servers, null);

  }

  /**

   * Start a minidfscluster.

   * This is useful if you want to run datanode on distinct hosts for things

   * like HDFS block location verification.

   * If you start MiniDFSCluster without host names, all instances of the

   * datanodes will have the same host name.

   * @param hosts hostnames DNs to run on.

   * @throws Exception

   * @see {@link #shutdownMiniDFSCluster()}

   * @return The mini dfs cluster created.

   */

  public MiniDFSCluster startMiniDFSCluster(final String hosts[])

    throws Exception {

    if ( hosts != null && hosts.length != 0) {

      return startMiniDFSCluster(hosts.length, hosts);

    } else {

      return startMiniDFSCluster(1, null);

    }

  }

  /**

   * Start a minidfscluster.

   * Can only create one.

   * @param servers How many DNs to start.

   * @param hosts hostnames DNs to run on.

   * @throws Exception

   * @see {@link #shutdownMiniDFSCluster()}

   * @return The mini dfs cluster created.

   */

  public MiniDFSCluster startMiniDFSCluster(int servers, final String hosts[])

  throws Exception {

    // Check that there is not already a cluster running

    isRunningCluster();

    // Initialize the local directory used by the MiniDFS

    if (clusterTestDir == null) {

      setupClusterTestDir();

    }

    // We have to set this property as it is used by MiniCluster

    System.setProperty(TEST_DIRECTORY_KEY, this.clusterTestDir.toString());

    // Some tests also do this:

    //  System.getProperty("test.cache.data", "build/test/cache");

    // It's also deprecated

    System.setProperty("test.cache.data", this.clusterTestDir.toString());

    // Ok, now we can start

    this.dfsCluster = new MiniDFSCluster(0, this.conf, servers, true, true,

      true, null, null, hosts, null);

    // Set this just-started cluster as our filesystem.

    FileSystem fs = this.dfsCluster.getFileSystem();

    this.conf.set("fs.defaultFS", fs.getUri().toString());

    // Do old style too just to be safe.

    this.conf.set("fs.default.name", fs.getUri().toString());

    // Wait for the cluster to be totally up

    this.dfsCluster.waitClusterUp();

    return this.dfsCluster;

  }

  /**

   * Shuts down instance created by call to {@link #startMiniDFSCluster(int)}

   * or does nothing.

   * @throws Exception

   */

  public void shutdownMiniDFSCluster() throws Exception {

    if (this.dfsCluster != null) {

      // The below throws an exception per dn, AsynchronousCloseException.

      this.dfsCluster.shutdown();

      dfsCluster = null;

    }

  }

  /**

   * Call this if you only want a zk cluster.

   * @see #startMiniZKCluster() if you want zk + dfs + hbase mini cluster.

   * @throws Exception

   * @see #shutdownMiniZKCluster()

   * @return zk cluster started.

   */

  public MiniZooKeeperCluster startMiniZKCluster() throws Exception {

    return startMiniZKCluster(1);

  }

  /**

   * Call this if you only want a zk cluster.

   * @param zooKeeperServerNum

   * @see #startMiniZKCluster() if you want zk + dfs + hbase mini cluster.

   * @throws Exception

   * @see #shutdownMiniZKCluster()

   * @return zk cluster started.

   */

  public MiniZooKeeperCluster startMiniZKCluster(int zooKeeperServerNum)

      throws Exception {

    File zkClusterFile = new File(getClusterTestDir().toString());

    return startMiniZKCluster(zkClusterFile, zooKeeperServerNum);

  }

  private MiniZooKeeperCluster startMiniZKCluster(final File dir)

    throws Exception {

    return startMiniZKCluster(dir,1);

  }

  private MiniZooKeeperCluster startMiniZKCluster(final File dir,

      int zooKeeperServerNum)

  throws Exception {

    if (this.zkCluster != null) {

      throw new IOException("Cluster already running at " + dir);

    }

    this.passedZkCluster = false;

    this.zkCluster = new MiniZooKeeperCluster(this.getConfiguration());

    int clientPort =   this.zkCluster.startup(dir,zooKeeperServerNum);

    this.conf.set(HConstants.ZOOKEEPER_CLIENT_PORT,

      Integer.toString(clientPort));

    return this.zkCluster;

  }

  /**

   * Shuts down zk cluster created by call to {@link #startMiniZKCluster(File)}

   * or does nothing.

   * @throws IOException

   * @see #startMiniZKCluster()

   */

  public void shutdownMiniZKCluster() throws IOException {

    if (this.zkCluster != null) {

      this.zkCluster.shutdown();

      this.zkCluster = null;

    }

  }

  /**

   * Start up a minicluster of hbase, dfs, and zookeeper.

   * @throws Exception

   * @return Mini hbase cluster instance created.

   * @see {@link #shutdownMiniDFSCluster()}

   */

  public MiniHBaseCluster startMiniCluster() throws Exception {

    return startMiniCluster(1, 1);

  }

  /**

   * Start up a minicluster of hbase, optionally dfs, and zookeeper.

   * Modifies Configuration.  Homes the cluster data directory under a random

   * subdirectory in a directory under System property test.build.data.

   * Directory is cleaned up on exit.

   * @param numSlaves Number of slaves to start up.  We'll start this many

   * datanodes and regionservers.  If numSlaves is > 1, then make sure

   * hbase.regionserver.info.port is -1 (i.e. no ui per regionserver) otherwise

   * bind errors.

   * @throws Exception

   * @see {@link #shutdownMiniCluster()}

   * @return Mini hbase cluster instance created.

   */

  public MiniHBaseCluster startMiniCluster(final int numSlaves)

  throws Exception {

    return startMiniCluster(1, numSlaves);

  }

  /**

   * start minicluster

   * @throws Exception

   * @see {@link #shutdownMiniCluster()}

   * @return Mini hbase cluster instance created.

   */

  public MiniHBaseCluster startMiniCluster(final int numMasters,

    final int numSlaves)

  throws Exception {

    return startMiniCluster(numMasters, numSlaves, null);

  }

  /**

   * Start up a minicluster of hbase, optionally dfs, and zookeeper.

   * Modifies Configuration.  Homes the cluster data directory under a random

   * subdirectory in a directory under System property test.build.data.

   * Directory is cleaned up on exit.

   * @param numMasters Number of masters to start up.  We'll start this many

   * hbase masters.  If numMasters > 1, you can find the active/primary master

   * with {@link MiniHBaseCluster#getMaster()}.

   * @param numSlaves Number of slaves to start up.  We'll start this many

   * regionservers. If dataNodeHosts == null, this also indicates the number of

   * datanodes to start. If dataNodeHosts != null, the number of datanodes is

   * based on dataNodeHosts.length.

   * If numSlaves is > 1, then make sure

   * hbase.regionserver.info.port is -1 (i.e. no ui per regionserver) otherwise

   * bind errors.

   * @param dataNodeHosts hostnames DNs to run on.

   * This is useful if you want to run datanode on distinct hosts for things

   * like HDFS block location verification.

   * If you start MiniDFSCluster without host names,

   * all instances of the datanodes will have the same host name.

   * @throws Exception

   * @see {@link #shutdownMiniCluster()}

   * @return Mini hbase cluster instance created.

   */

  public MiniHBaseCluster startMiniCluster(final int numMasters,

    final int numSlaves, final String[] dataNodeHosts)

  throws Exception {

    int numDataNodes = numSlaves;

    if ( dataNodeHosts != null && dataNodeHosts.length != 0) {

      numDataNodes = dataNodeHosts.length;

    }

    LOG.info("Starting up minicluster with " + numMasters + " master(s) and " +

        numSlaves + " regionserver(s) and " + numDataNodes + " datanode(s)");

    // If we already put up a cluster, fail.

    isRunningCluster();

    // Bring up mini dfs cluster. This spews a bunch of warnings about missing

    // scheme. Complaints are 'Scheme is undefined for build/test/data/dfs/name1'.

    startMiniDFSCluster(numDataNodes, dataNodeHosts);

    // Start up a zk cluster.

    if (this.zkCluster == null) {

      startMiniZKCluster(clusterTestDir);

    }

    // Start the MiniHBaseCluster

    return startMiniHBaseCluster(numMasters, numSlaves);

  }

  /**

   * Starts up mini hbase cluster.  Usually used after call to

   * {@link #startMiniCluster(int, int)} when doing stepped startup of clusters.

   * Usually you won't want this.  You'll usually want {@link #startMiniCluster()}.

   * @param numMasters

   * @param numSlaves

   * @return Reference to the hbase mini hbase cluster.

   * @throws IOException

   * @throws InterruptedException

   * @see {@link #startMiniCluster()}

   */

  public MiniHBaseCluster startMiniHBaseCluster(final int numMasters,

      final int numSlaves)

  throws IOException, InterruptedException {

    // Now do the mini hbase cluster.  Set the hbase.rootdir in config.

    createRootDir();

    // These settings will make the server waits until this exact number of

    // regions servers are connected.

    if (conf.getInt(ServerManager.WAIT_ON_REGIONSERVERS_MINTOSTART, -1) == -1) {

      conf.setInt(ServerManager.WAIT_ON_REGIONSERVERS_MINTOSTART, numSlaves);

    }

    if (conf.getInt(ServerManager.WAIT_ON_REGIONSERVERS_MAXTOSTART, -1) == -1) {

      conf.setInt(ServerManager.WAIT_ON_REGIONSERVERS_MAXTOSTART, numSlaves);

    }

    Configuration c = new Configuration(this.conf);

    this.hbaseCluster = new MiniHBaseCluster(c, numMasters, numSlaves);

    // Don't leave here till we've done a successful scan of the .META.

    HTable t = new HTable(c, HConstants.META_TABLE_NAME);

    ResultScanner s = t.getScanner(new Scan());

    while (s.next() != null) {

      continue;

    }

    s.close();

    t.close();

    getHBaseAdmin(); // create immediately the hbaseAdmin

    LOG.info("Minicluster is up");

    return (MiniHBaseCluster)this.hbaseCluster;

  }

  /**

   * Starts the hbase cluster up again after shutting it down previously in a

   * test.  Use this if you want to keep dfs/zk up and just stop/start hbase.

   * @param servers number of region servers

   * @throws IOException

   */

  public void restartHBaseCluster(int servers) throws IOException, InterruptedException {

    this.hbaseCluster = new MiniHBaseCluster(this.conf, servers);

    // Don't leave here till we've done a successful scan of the .META.

    HTable t = new HTable(new Configuration(this.conf), HConstants.META_TABLE_NAME);

    ResultScanner s = t.getScanner(new Scan());

    while (s.next() != null) {

      // do nothing

    }

    LOG.info("HBase has been restarted");

    s.close();

    t.close();

  }

  /**

   * @return Current mini hbase cluster. Only has something in it after a call

   * to {@link #startMiniCluster()}.

   * @see #startMiniCluster()

   */

  public MiniHBaseCluster getMiniHBaseCluster() {

    if (this.hbaseCluster instanceof MiniHBaseCluster) {

      return (MiniHBaseCluster)this.hbaseCluster;

    }

    throw new RuntimeException(hbaseCluster + " not an instance of " +

                               MiniHBaseCluster.class.getName());

  }

  /**

   * Stops mini hbase, zk, and hdfs clusters.

   * @throws IOException

   * @see {@link #startMiniCluster(int)}

   */

  public void shutdownMiniCluster() throws Exception {

    LOG.info("Shutting down minicluster");

    shutdownMiniHBaseCluster();

    if (!this.passedZkCluster){

      shutdownMiniZKCluster();

    }

    shutdownMiniDFSCluster();

    // Clean up our directory.

    if (this.clusterTestDir != null && this.clusterTestDir.exists()) {

      // Need to use deleteDirectory because File.delete required dir is empty.

      if (!FSUtils.deleteDirectory(FileSystem.getLocal(this.conf),

          new Path(this.clusterTestDir.toString()))) {

        LOG.warn("Failed delete of " + this.clusterTestDir.toString());

      }

      this.clusterTestDir = null;

    }

    LOG.info("Minicluster is down");

  }

  /**

   * Shutdown HBase mini cluster.  Does not shutdown zk or dfs if running.

   * @throws IOException

   */

  public void shutdownMiniHBaseCluster() throws IOException {

    if (hbaseAdmin != null) {

      hbaseAdmin.close();

      hbaseAdmin = null;

    }

    // unset the configuration for MIN and MAX RS to start

    conf.setInt(ServerManager.WAIT_ON_REGIONSERVERS_MINTOSTART, -1);

    conf.setInt(ServerManager.WAIT_ON_REGIONSERVERS_MAXTOSTART, -1);

    if (this.hbaseCluster != null) {

      this.hbaseCluster.shutdown();

      // Wait till hbase is down before going on to shutdown zk.

      this.hbaseCluster.waitUntilShutDown();

      this.hbaseCluster = null;

    }

  }

  /**

   * Returns the path to the default root dir the minicluster uses.

   * Note: this does not cause the root dir to be created.

   * @return Fully qualified path for the default hbase root dir

   * @throws IOException

   */

  public Path getDefaultRootDirPath() throws IOException {

  FileSystem fs = FileSystem.get(this.conf);

  return new Path(fs.makeQualified(fs.getHomeDirectory()),"hbase");

  }

  /**

   * Creates an hbase rootdir in user home directory.  Also creates hbase

   * version file.  Normally you won't make use of this method.  Root hbasedir

   * is created for you as part of mini cluster startup.  You'd only use this

   * method if you were doing manual operation.

   * @return Fully qualified path to hbase root dir

   * @throws IOException

   */

  public Path createRootDir() throws IOException {

    FileSystem fs = FileSystem.get(this.conf);

    Path hbaseRootdir = getDefaultRootDirPath();

    this.conf.set(HConstants.HBASE_DIR, hbaseRootdir.toString());

    fs.mkdirs(hbaseRootdir);

    FSUtils.setVersion(fs, hbaseRootdir);

    return hbaseRootdir;

  }

  /**

   * Flushes all caches in the mini hbase cluster

   * @throws IOException

   */

  public void flush() throws IOException {

    getMiniHBaseCluster().flushcache();

  }

  /**

   * Flushes all caches in the mini hbase cluster

   * @throws IOException

   */

  public void flush(byte [] tableName) throws IOException {

    getMiniHBaseCluster().flushcache(tableName);

  }

  /**

   * Compact all regions in the mini hbase cluster

   * @throws IOException

   */

  public void compact(boolean major) throws IOException {

    getMiniHBaseCluster().compact(major);

  }

  /**

   * Compact all of a table's reagion in the mini hbase cluster

   * @throws IOException

   */

  public void compact(byte [] tableName, boolean major) throws IOException {

    getMiniHBaseCluster().compact(tableName, major);

  }

  /**

   * Create a table.

   * @param tableName

   * @param family

   * @return An HTable instance for the created table.

   * @throws IOException

   */

  public HTable createTable(byte[] tableName, byte[] family)

  throws IOException{

    return createTable(tableName, new byte[][]{family});

  }

  /**

   * Create a table.

   * @param tableName

   * @param families

   * @return An HTable instance for the created table.

   * @throws IOException

   */

  public HTable createTable(byte[] tableName, byte[][] families)

  throws IOException {

    return createTable(tableName, families,

        new Configuration(getConfiguration()));

  }

  public HTable createTable(byte[] tableName, byte[][] families,

      int numVersions, byte[] startKey, byte[] endKey, int numRegions)

  throws IOException{

    HTableDescriptor desc = new HTableDescriptor(tableName);

    for (byte[] family : families) {

      HColumnDescriptor hcd = new HColumnDescriptor(family)

          .setMaxVersions(numVersions);

      desc.addFamily(hcd);

    }

    getHBaseAdmin().createTable(desc, startKey, endKey, numRegions);

    return new HTable(getConfiguration(), tableName);

  }

  /**

   * Create a table.

   * @param tableName

   * @param families

   * @param c Configuration to use

   * @return An HTable instance for the created table.

   * @throws IOException

   */

  public HTable createTable(byte[] tableName, byte[][] families,

      final Configuration c)

  throws IOException {

    HTableDescriptor desc = new HTableDescriptor(tableName);

    for(byte[] family : families) {

      desc.addFamily(new HColumnDescriptor(family));

    }

    getHBaseAdmin().createTable(desc);

    return new HTable(c, tableName);

  }

  /**

   * Create a table.

   * @param tableName

   * @param families

   * @param c Configuration to use

   * @param numVersions

   * @return An HTable instance for the created table.

   * @throws IOException

   */

  public HTable createTable(byte[] tableName, byte[][] families,

      final Configuration c, int numVersions)

  throws IOException {

    HTableDescriptor desc = new HTableDescriptor(tableName);

    for(byte[] family : families) {

      HColumnDescriptor hcd = new HColumnDescriptor(family)

          .setMaxVersions(numVersions);

      desc.addFamily(hcd);

    }

    getHBaseAdmin().createTable(desc);

    return new HTable(c, tableName);

  }

  /**

   * Create a table.

   * @param tableName

   * @param family

   * @param numVersions

   * @return An HTable instance for the created table.

   * @throws IOException

   */

  public HTable createTable(byte[] tableName, byte[] family, int numVersions)

  throws IOException {

    return createTable(tableName, new byte[][]{family}, numVersions);

  }

  /**

   * Create a table.

   * @param tableName

   * @param families

   * @param numVersions

   * @return An HTable instance for the created table.

   * @throws IOException

   */

  public HTable createTable(byte[] tableName, byte[][] families,

      int numVersions)

  throws IOException {

    HTableDescriptor desc = new HTableDescriptor(tableName);

    for (byte[] family : families) {

      HColumnDescriptor hcd = new HColumnDescriptor(family)

          .setMaxVersions(numVersions);

      desc.addFamily(hcd);

    }

    getHBaseAdmin().createTable(desc);

    return new HTable(new Configuration(getConfiguration()), tableName);

  }

  /**

   * Create a table.

   * @param tableName

   * @param families

   * @param numVersions

   * @return An HTable instance for the created table.

   * @throws IOException

   */

  public HTable createTable(byte[] tableName, byte[][] families,

    int numVersions, int blockSize) throws IOException {

    HTableDescriptor desc = new HTableDescriptor(tableName);

    for (byte[] family : families) {

      HColumnDescriptor hcd = new HColumnDescriptor(family)

          .setMaxVersions(numVersions)

          .setBlocksize(blockSize);

      desc.addFamily(hcd);

    }

    getHBaseAdmin().createTable(desc);

    return new HTable(new Configuration(getConfiguration()), tableName);

  }

  /**

   * Create a table.

   * @param tableName

   * @param families

   * @param numVersions

   * @return An HTable instance for the created table.

   * @throws IOException

   */

  public HTable createTable(byte[] tableName, byte[][] families,

      int[] numVersions)

  throws IOException {

    HTableDescriptor desc = new HTableDescriptor(tableName);

    int i = 0;

    for (byte[] family : families) {

      HColumnDescriptor hcd = new HColumnDescriptor(family)

          .setMaxVersions(numVersions[i]);

      desc.addFamily(hcd);