* Copyright 2011 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.

*/

* Provides an interface to manage HBase database table metadata + general

* administrative functions.  Use HBaseAdmin to create, drop, list, enable and

* disable tables. Use it also to add and drop table column families.

*

* <p>See {@link HTable} to add, update, and delete data from an individual table.

* <p>Currently HBaseAdmin instances are not expected to be long-lived.  For

* example, an HBaseAdmin instance will not ride over a Master restart.

*/

  private final Log LOG = LogFactory.getLog(this.getClass().getName());

  private HConnection connection;

  private volatile Configuration conf;

  private final long pause;

  private final int numRetries;

  // Some operations can take a long time such as disable of big table.

  // numRetries is for 'normal' stuff... Mutliply by this factor when

  // want to wait a long time.

  private final int retryLongerMultiplier;

  private boolean aborted;

  private static volatile boolean synchronousBalanceSwitchSupported = true;

  private final boolean cleanupConnectionOnClose; // close the connection in close()

  /**

   * Constructor

   *

   * @param c Configuration object

   * @throws MasterNotRunningException if the master is not running

   * @throws ZooKeeperConnectionException if unable to connect to zookeeper

   */

  public HBaseAdmin(Configuration c)

  throws MasterNotRunningException, ZooKeeperConnectionException {

    this.conf = HBaseConfiguration.create(c);

    this.connection = HConnectionManager.getConnection(this.conf);

    this.pause = this.conf.getLong("hbase.client.pause", 1000);

    this.numRetries = this.conf.getInt("hbase.client.retries.number", 10);

    this.retryLongerMultiplier = this.conf.getInt(

        "hbase.client.retries.longer.multiplier", 10);

    this.cleanupConnectionOnClose = true;

    int tries = 0;

    while ( true ){

      try {

        this.connection.getMaster();

        return;

      } catch (MasterNotRunningException mnre) {

        HConnectionManager.deleteStaleConnection(this.connection);

        this.connection = HConnectionManager.getConnection(this.conf);

      }

      tries++;

      if (tries >= numRetries) {

        // we should delete connection between client and zookeeper

        HConnectionManager.deleteStaleConnection(this.connection);

        throw new MasterNotRunningException("Retried " + numRetries + " times");

      }

      try {

        Thread.sleep(getPauseTime(tries));

      } catch (InterruptedException e) {

        Thread.currentThread().interrupt();

        // we should delete connection between client and zookeeper

        HConnectionManager.deleteStaleConnection(this.connection);

        throw new MasterNotRunningException(

          "Interrupted after "+tries+" tries");

      }

    }

  }

/**

   * Constructor for externally managed HConnections.

   * This constructor fails fast if the HMaster is not running.

   * The HConnection can be re-used again in another attempt.

   * This constructor fails fast.

   *

   * @param connection The HConnection instance to use

   * @throws MasterNotRunningException if the master is not running

   * @throws ZooKeeperConnectionException if unable to connect to zookeeper

   */

  public HBaseAdmin(HConnection connection)

      throws MasterNotRunningException, ZooKeeperConnectionException {

    this.conf = connection.getConfiguration();

    this.connection = connection;

    this.cleanupConnectionOnClose = false;

    this.pause = this.conf.getLong("hbase.client.pause", 1000);

    this.numRetries = this.conf.getInt("hbase.client.retries.number", 10);

    this.retryLongerMultiplier = this.conf.getInt(

        "hbase.client.retries.longer.multiplier", 10);

    this.connection.getMaster();

  }

  /**

   * @return A new CatalogTracker instance; call {@link #cleanupCatalogTracker(CatalogTracker)}

   * to cleanup the returned catalog tracker.

   * @throws ZooKeeperConnectionException

   * @throws IOException

   * @see #cleanupCatalogTracker(CatalogTracker)

   */

  private synchronized CatalogTracker getCatalogTracker()

  throws ZooKeeperConnectionException, IOException {

    CatalogTracker ct = null;

    try {

      ct = new CatalogTracker(this.conf);

      ct.start();

    } catch (InterruptedException e) {

      // Let it out as an IOE for now until we redo all so tolerate IEs

      Thread.currentThread().interrupt();

      throw new IOException("Interrupted", e);

    }

    return ct;

  }

  private void cleanupCatalogTracker(final CatalogTracker ct) {

    ct.stop();

  }

  @Override

  public void abort(String why, Throwable e) {

    // Currently does nothing but throw the passed message and exception

    this.aborted = true;

    throw new RuntimeException(why, e);

  }

  @Override

  public boolean isAborted(){

    return this.aborted;

  }

  /** @return HConnection used by this object. */

  public HConnection getConnection() {

    return connection;

  }

  /**

   * Get a connection to the currently set master.

   * @return proxy connection to master server for this instance

   * @throws MasterNotRunningException if the master is not running

   * @throws ZooKeeperConnectionException if unable to connect to zookeeper

   * @deprecated  Master is an implementation detail for HBaseAdmin.

   * Deprecated in HBase 0.94

   */

  @Deprecated

  public HMasterInterface getMaster()

  throws MasterNotRunningException, ZooKeeperConnectionException {

    return this.connection.getMaster();

  }

  /** @return - true if the master server is running

   * @throws ZooKeeperConnectionException

   * @throws MasterNotRunningException */

  public boolean isMasterRunning()

  throws MasterNotRunningException, ZooKeeperConnectionException {

    return this.connection.isMasterRunning();

  }

  /**

   * @param tableName Table to check.

   * @return True if table exists already.

   * @throws IOException

   */

  public boolean tableExists(final String tableName)

  throws IOException {

    boolean b = false;

    CatalogTracker ct = getCatalogTracker();

    try {

      b = MetaReader.tableExists(ct, tableName);

    } finally {

      cleanupCatalogTracker(ct);

    }

    return b;

  }

  /**

   * @param tableName Table to check.

   * @return True if table exists already.

   * @throws IOException

   */

  public boolean tableExists(final byte [] tableName)

  throws IOException {

    return tableExists(Bytes.toString(tableName));

  }

  /**

   * List all the userspace tables.  In other words, scan the META table.

   *

   * If we wanted this to be really fast, we could implement a special

   * catalog table that just contains table names and their descriptors.

   * Right now, it only exists as part of the META table's region info.

   *

   * @return - returns an array of HTableDescriptors

   * @throws IOException if a remote or network exception occurs

   */

  public HTableDescriptor[] listTables() throws IOException {

    return this.connection.listTables();

  }

  /**

   * List all the userspace tables matching the given pattern.

   *

   * @param pattern The compiled regular expression to match against

   * @return - returns an array of HTableDescriptors

   * @throws IOException if a remote or network exception occurs

   * @see #listTables()

   */

  public HTableDescriptor[] listTables(Pattern pattern) throws IOException {

    List<HTableDescriptor> matched = new LinkedList<HTableDescriptor>();

    HTableDescriptor[] tables = listTables();

    for (HTableDescriptor table : tables) {

      if (pattern.matcher(table.getNameAsString()).matches()) {

        matched.add(table);

      }

    }

    return matched.toArray(new HTableDescriptor[matched.size()]);

  }

  /**

   * List all the userspace tables matching the given regular expression.

   *

   * @param regex The regular expression to match against

   * @return - returns an array of HTableDescriptors

   * @throws IOException if a remote or network exception occurs

   * @see #listTables(java.util.regex.Pattern)

   */

  public HTableDescriptor[] listTables(String regex) throws IOException {

    return listTables(Pattern.compile(regex));

  }

  /**

   * List all of the names of userspace tables.

   * @return the list of table names

   * @throws IOException if a remote or network exception occurs

   */

  public String[] getTableNames() throws IOException {

    return this.connection.getTableNames();

  }

  /**

   * List all of the names of userspace tables matching the given pattern

   * @param pattern The compiled regular expression to match against

   * @return the list of table names

   * @throws IOException if a remote or network exception occurs

   */

  public String[] getTableNames(Pattern pattern) throws IOException {

    List<String> matched = new ArrayList<String>();

    for (String name : this.connection.getTableNames()) {

      if (pattern.matcher(name).matches()) {

        matched.add(name);

      }

    }

    return matched.toArray(new String[matched.size()]);

  }

  /**

   * List all of the names of userspace tables matching the given regex

   * @param regex The regular expression to match against

   * @return the list of table names

   * @throws IOException if a remote or network exception occurs

   */

  public String[] getTableNames(String regex) throws IOException {

    return getTableNames(Pattern.compile(regex));

  }

  /**

   * Method for getting the tableDescriptor

   * @param tableName as a byte []

   * @return the tableDescriptor

   * @throws TableNotFoundException

   * @throws IOException if a remote or network exception occurs

   */

  public HTableDescriptor getTableDescriptor(final byte [] tableName)

  throws TableNotFoundException, IOException {

    return this.connection.getHTableDescriptor(tableName);

  }

  private long getPauseTime(int tries) {

    int triesCount = tries;

    if (triesCount >= HConstants.RETRY_BACKOFF.length) {

      triesCount = HConstants.RETRY_BACKOFF.length - 1;

    }

    return this.pause * HConstants.RETRY_BACKOFF[triesCount];

  }

  /**

   * Creates a new table.

   * Synchronous operation.

   *

   * @param desc table descriptor for table

   *

   * @throws IllegalArgumentException if the table name is reserved

   * @throws MasterNotRunningException if master is not running

   * @throws TableExistsException if table already exists (If concurrent

   * threads, the table may have been created between test-for-existence

   * and attempt-at-creation).

   * @throws IOException if a remote or network exception occurs

   */

  public void createTable(HTableDescriptor desc)

  throws IOException {

    createTable(desc, null);

  }

  /**

   * Creates a new table with the specified number of regions.  The start key

   * specified will become the end key of the first region of the table, and

   * the end key specified will become the start key of the last region of the

   * table (the first region has a null start key and the last region has a

   * null end key).

   *

   * BigInteger math will be used to divide the key range specified into

   * enough segments to make the required number of total regions.

   *

   * Synchronous operation.

   *

   * @param desc table descriptor for table

   * @param startKey beginning of key range

   * @param endKey end of key range

   * @param numRegions the total number of regions to create

   *

   * @throws IllegalArgumentException if the table name is reserved

   * @throws MasterNotRunningException if master is not running

   * @throws TableExistsException if table already exists (If concurrent

   * threads, the table may have been created between test-for-existence

   * and attempt-at-creation).

   * @throws IOException

   */

  public void createTable(HTableDescriptor desc, byte [] startKey,

      byte [] endKey, int numRegions)

  throws IOException {

    HTableDescriptor.isLegalTableName(desc.getName());

    if(numRegions < 3) {

      throw new IllegalArgumentException("Must create at least three regions");

    } else if(Bytes.compareTo(startKey, endKey) >= 0) {

      throw new IllegalArgumentException("Start key must be smaller than end key");

    }

    if (numRegions == 3) {

      createTable(desc, new byte[][] { startKey, endKey });

      return;

    }

    byte [][] splitKeys = Bytes.split(startKey, endKey, numRegions - 3);

    if(splitKeys == null || splitKeys.length != numRegions - 1) {

      throw new IllegalArgumentException("Unable to split key range into enough regions");

    }

    createTable(desc, splitKeys);

  }

  /**

   * Creates a new table with an initial set of empty regions defined by the

   * specified split keys.  The total number of regions created will be the

   * number of split keys plus one. Synchronous operation.

   * Note : Avoid passing empty split key.

   *

   * @param desc table descriptor for table

   * @param splitKeys array of split keys for the initial regions of the table

   *

   * @throws IllegalArgumentException if the table name is reserved, if the split keys

   * are repeated and if the split key has empty byte array.

   * @throws MasterNotRunningException if master is not running

   * @throws TableExistsException if table already exists (If concurrent

   * threads, the table may have been created between test-for-existence

   * and attempt-at-creation).

   * @throws IOException

   */

  public void createTable(final HTableDescriptor desc, byte [][] splitKeys)

  throws IOException {

    HTableDescriptor.isLegalTableName(desc.getName());

    try {

      createTableAsync(desc, splitKeys);

    } catch (SocketTimeoutException ste) {

      LOG.warn("Creating " + desc.getNameAsString() + " took too long", ste);

    }

    int numRegs = splitKeys == null ? 1 : splitKeys.length + 1;

    int prevRegCount = 0;

    boolean doneWithMetaScan = false;

    for (int tries = 0; tries < this.numRetries * this.retryLongerMultiplier;

      ++tries) {

      if (!doneWithMetaScan) {

        // Wait for new table to come on-line

        final AtomicInteger actualRegCount = new AtomicInteger(0);

        MetaScannerVisitor visitor = new MetaScannerVisitorBase() {

          @Override

          public boolean processRow(Result rowResult) throws IOException {

            if (rowResult == null || rowResult.size() <= 0) {

              return true;

            }

            HRegionInfo info = MetaReader.parseHRegionInfoFromCatalogResult(

              rowResult, HConstants.REGIONINFO_QUALIFIER);

            if (info == null) {

              LOG.warn("No serialized HRegionInfo in " + rowResult);

              return true;

            }

            if (!(Bytes.equals(info.getTableName(), desc.getName()))) {

              return false;

            }

            String hostAndPort = null;

            byte [] value = rowResult.getValue(HConstants.CATALOG_FAMILY,

              HConstants.SERVER_QUALIFIER);

            // Make sure that regions are assigned to server

            if (value != null && value.length > 0) {

              hostAndPort = Bytes.toString(value);

            }

            if (!(info.isOffline() || info.isSplit()) && hostAndPort != null) {

              actualRegCount.incrementAndGet();

            }

            return true;

          }

        };

        MetaScanner.metaScan(conf, connection, visitor, desc.getName());

        if (actualRegCount.get() < numRegs) {

          if (tries == this.numRetries * this.retryLongerMultiplier - 1) {

            throw new RegionOfflineException("Only " + actualRegCount.get() +

              " of " + numRegs + " regions are online; retries exhausted.");

          }

          try { // Sleep

            Thread.sleep(getPauseTime(tries));

          } catch (InterruptedException e) {

            throw new InterruptedIOException("Interrupted when opening" +

              " regions; " + actualRegCount.get() + " of " + numRegs +

              " regions processed so far");

          }

          if (actualRegCount.get() > prevRegCount) { // Making progress

            prevRegCount = actualRegCount.get();

            tries = -1;

          }

        } else {

          doneWithMetaScan = true;

          tries = -1;

        }

      } else if (isTableEnabled(desc.getName())) {

        return;

      } else {

        try { // Sleep

          Thread.sleep(getPauseTime(tries));

        } catch (InterruptedException e) {

          throw new InterruptedIOException("Interrupted when waiting" +

            " for table to be enabled; meta scan was done");

        }

      }

    }

    throw new TableNotEnabledException(

      "Retries exhausted while still waiting for table: "

      + desc.getNameAsString() + " to be enabled");

  }

  /**

   * Creates a new table but does not block and wait for it to come online.

   * Asynchronous operation.  To check if the table exists, use

   * {@link: #isTableAvailable} -- it is not safe to create an HTable

   * instance to this table before it is available.

   * Note : Avoid passing empty split key.

   * @param desc table descriptor for table

   *

   * @throws IllegalArgumentException Bad table name, if the split keys

   * are repeated and if the split key has empty byte array.

   * @throws MasterNotRunningException if master is not running

   * @throws TableExistsException if table already exists (If concurrent

   * threads, the table may have been created between test-for-existence

   * and attempt-at-creation).

   * @throws IOException

   */

  public void createTableAsync(HTableDescriptor desc, byte [][] splitKeys)

  throws IOException {

    HTableDescriptor.isLegalTableName(desc.getName());

    if(splitKeys != null && splitKeys.length > 0) {

      Arrays.sort(splitKeys, Bytes.BYTES_COMPARATOR);

      // Verify there are no duplicate split keys

      byte [] lastKey = null;

      for(byte [] splitKey : splitKeys) {

        if (Bytes.compareTo(splitKey, HConstants.EMPTY_BYTE_ARRAY) == 0) {

          throw new IllegalArgumentException(

              "Empty split key must not be passed in the split keys.");

        }

        if(lastKey != null && Bytes.equals(splitKey, lastKey)) {

          throw new IllegalArgumentException("All split keys must be unique, " +

            "found duplicate: " + Bytes.toStringBinary(splitKey) +

            ", " + Bytes.toStringBinary(lastKey));

        }

        lastKey = splitKey;

      }

    }

    try {

      getMaster().createTable(desc, splitKeys);

    } catch (RemoteException e) {

      throw e.unwrapRemoteException();

    }

  }

  /**

   * Deletes a table.

   * Synchronous operation.

   *

   * @param tableName name of table to delete

   * @throws IOException if a remote or network exception occurs

   */

  public void deleteTable(final String tableName) throws IOException {

    deleteTable(Bytes.toBytes(tableName));

  }

  /**

   * Deletes a table.

   * Synchronous operation.

   *

   * @param tableName name of table to delete

   * @throws IOException if a remote or network exception occurs

   */

  public void deleteTable(final byte [] tableName) throws IOException {

    isMasterRunning();

    HTableDescriptor.isLegalTableName(tableName);

    HRegionLocation firstMetaServer = getFirstMetaServerForTable(tableName);

    boolean tableExists = true;

    try {

      getMaster().deleteTable(tableName);

    } catch (RemoteException e) {

      throw RemoteExceptionHandler.decodeRemoteException(e);

    }

    // Wait until all regions deleted

    HRegionInterface server =

      connection.getHRegionConnection(firstMetaServer.getHostname(), firstMetaServer.getPort());

    List<String> tableNameAsList = new ArrayList<String>(1);

    tableNameAsList.add(Bytes.toString(tableName));

    for (int tries = 0; tries < (this.numRetries * this.retryLongerMultiplier); tries++) {

      long scannerId = -1L;

      try {

        Scan scan = MetaReader.getScanForTableName(tableName);

        scan.addColumn(HConstants.CATALOG_FAMILY,

            HConstants.REGIONINFO_QUALIFIER);

        scannerId = server.openScanner(

          firstMetaServer.getRegionInfo().getRegionName(), scan);

        // Get a batch at a time.

        Result values = server.next(scannerId);

        // let us wait until .META. table is updated and

        // HMaster removes the table from its HTableDescriptors

        if (values == null) {

          tableExists = false;

          HTableDescriptor[] htds = getMaster().getHTableDescriptors(tableNameAsList);

          tableExists = (htds != null && htds.length > 0);

          if (!tableExists) {

            break;

          }

        }

      } catch (IOException ex) {

        if(tries == numRetries - 1) {           // no more tries left

          if (ex instanceof RemoteException) {

            ex = RemoteExceptionHandler.decodeRemoteException((RemoteException) ex);

          }

          throw ex;

        }

      } finally {

        if (scannerId != -1L) {

          try {

            server.close(scannerId);

          } catch (Exception ex) {

            LOG.warn(ex);

          }

        }

      }

      try {

        Thread.sleep(getPauseTime(tries));

      } catch (InterruptedException e) {

        // continue

      }

    }

    if (tableExists) {

      throw new IOException("Retries exhausted, it took too long to wait"+

        " for the table " + Bytes.toString(tableName) + " to be deleted.");

    }

    // Delete cached information to prevent clients from using old locations

    this.connection.clearRegionCache(tableName);

    LOG.info("Deleted " + Bytes.toString(tableName));

  }

  /**

   * Deletes tables matching the passed in pattern and wait on completion.

   *

   * Warning: Use this method carefully, there is no prompting and the effect is

   * immediate. Consider using {@link #listTables(java.lang.String)} and

   * {@link #deleteTable(byte[])}

   *

   * @param regex The regular expression to match table names against

   * @return Table descriptors for tables that couldn't be deleted

   * @throws IOException

   * @see #deleteTables(java.util.regex.Pattern)

   * @see #deleteTable(java.lang.String)

   */

  public HTableDescriptor[] deleteTables(String regex) throws IOException {

    return deleteTables(Pattern.compile(regex));

  }

  /**

   * Delete tables matching the passed in pattern and wait on completion.

   *

   * Warning: Use this method carefully, there is no prompting and the effect is

   * immediate. Consider using {@link #listTables(java.util.regex.Pattern) } and

   * {@link #deleteTable(byte[])}

   *

   * @param pattern The pattern to match table names against

   * @return Table descriptors for tables that couldn't be deleted

   * @throws IOException

   */

  public HTableDescriptor[] deleteTables(Pattern pattern) throws IOException {

    List<HTableDescriptor> failed = new LinkedList<HTableDescriptor>();

    for (HTableDescriptor table : listTables(pattern)) {

      try {

        deleteTable(table.getName());

      } catch (IOException ex) {

        LOG.info("Failed to delete table " + table.getNameAsString(), ex);

        failed.add(table);

      }

    }

    return failed.toArray(new HTableDescriptor[failed.size()]);

  }

  public void enableTable(final String tableName)

  throws IOException {

    enableTable(Bytes.toBytes(tableName));

  }

  /**

   * Enable a table.  May timeout.  Use {@link #enableTableAsync(byte[])}

   * and {@link #isTableEnabled(byte[])} instead.

   * The table has to be in disabled state for it to be enabled.

   * @param tableName name of the table

   * @throws IOException if a remote or network exception occurs

   * There could be couple types of IOException

   * TableNotFoundException means the table doesn't exist.

   * TableNotDisabledException means the table isn't in disabled state.

   * @see #isTableEnabled(byte[])

   * @see #disableTable(byte[])

   * @see #enableTableAsync(byte[])

   */

  public void enableTable(final byte [] tableName)

  throws IOException {

    enableTableAsync(tableName);

    // Wait until all regions are enabled

    waitUntilTableIsEnabled(tableName);

    LOG.info("Enabled table " + Bytes.toString(tableName));

  }

  /**

   * Wait for the table to be enabled and available

   * If enabling the table exceeds the retry period, an exception is thrown.

   * @param tableName name of the table

   * @throws IOException if a remote or network exception occurs or

   *    table is not enabled after the retries period.

   */

  private void waitUntilTableIsEnabled(final byte[] tableName) throws IOException {

    boolean enabled = false;

    long start = EnvironmentEdgeManager.currentTimeMillis();

    for (int tries = 0; tries < (this.numRetries * this.retryLongerMultiplier); tries++) {

      enabled = isTableEnabled(tableName) && isTableAvailable(tableName);

      if (enabled) {

        break;

      }

      long sleep = getPauseTime(tries);

      if (LOG.isDebugEnabled()) {

        LOG.debug("Sleeping= " + sleep + "ms, waiting for all regions to be " +

          "enabled in " + Bytes.toString(tableName));

      }

      try {

        Thread.sleep(sleep);

      } catch (InterruptedException e) {

        Thread.currentThread().interrupt();

        // Do this conversion rather than let it out because do not want to

        // change the method signature.

        throw new IOException("Interrupted", e);

      }

    }

    if (!enabled) {

      long msec = EnvironmentEdgeManager.currentTimeMillis() - start;

      throw new IOException("Table '" + Bytes.toString(tableName) +

        "' not yet enabled, after " + msec + "ms.");

    }

  }

  public void enableTableAsync(final String tableName)

  throws IOException {

    enableTableAsync(Bytes.toBytes(tableName));

  }

  /**

   * Brings a table on-line (enables it).  Method returns immediately though

   * enable of table may take some time to complete, especially if the table

   * is large (All regions are opened as part of enabling process).  Check

   * {@link #isTableEnabled(byte[])} to learn when table is fully online.  If

   * table is taking too long to online, check server logs.

   * @param tableName

   * @throws IOException

   * @since 0.90.0

   */

  public void enableTableAsync(final byte [] tableName)

  throws IOException {

    HTableDescriptor.isLegalTableName(tableName);

    isMasterRunning();

    try {

      getMaster().enableTable(tableName);

    } catch (RemoteException e) {

      throw e.unwrapRemoteException();

    }

    LOG.info("Started enable of " + Bytes.toString(tableName));

  }

  /**

   * Enable tables matching the passed in pattern and wait on completion.

   *

   * Warning: Use this method carefully, there is no prompting and the effect is

   * immediate. Consider using {@link #listTables(java.lang.String)} and

   * {@link #enableTable(byte[])}

   *

   * @param regex The regular expression to match table names against

   * @throws IOException

   * @see #enableTables(java.util.regex.Pattern)

   * @see #enableTable(java.lang.String)

   */

  public HTableDescriptor[] enableTables(String regex) throws IOException {

    return enableTables(Pattern.compile(regex));

  }

  /**

   * Enable tables matching the passed in pattern and wait on completion.

   *

   * Warning: Use this method carefully, there is no prompting and the effect is

   * immediate. Consider using {@link #listTables(java.util.regex.Pattern) } and

   * {@link #enableTable(byte[])}

   *

   * @param pattern The pattern to match table names against

   * @throws IOException

   */

  public HTableDescriptor[] enableTables(Pattern pattern) throws IOException {

    List<HTableDescriptor> failed = new LinkedList<HTableDescriptor>();

    for (HTableDescriptor table : listTables(pattern)) {

      if (isTableDisabled(table.getName())) {

        try {

          enableTable(table.getName());

        } catch (IOException ex) {

          LOG.info("Failed to enable table " + table.getNameAsString(), ex);

          failed.add(table);

        }

      }

    }

    return failed.toArray(new HTableDescriptor[failed.size()]);

  }

  public void disableTableAsync(final String tableName) throws IOException {

    disableTableAsync(Bytes.toBytes(tableName));

  }

  /**

   * Starts the disable of a table.  If it is being served, the master

   * will tell the servers to stop serving it.  This method returns immediately.

   * The disable of a table can take some time if the table is large (all

   * regions are closed as part of table disable operation).

   * Call {@link #isTableDisabled(byte[])} to check for when disable completes.

   * If table is taking too long to online, check server logs.

   * @param tableName name of table

   * @throws IOException if a remote or network exception occurs

   * @see #isTableDisabled(byte[])

   * @see #isTableEnabled(byte[])

   * @since 0.90.0

   */

  public void disableTableAsync(final byte [] tableName) throws IOException {

    HTableDescriptor.isLegalTableName(tableName);

    isMasterRunning();

    try {

      getMaster().disableTable(tableName);

    } catch (RemoteException e) {

      throw e.unwrapRemoteException();

    }

    LOG.info("Started disable of " + Bytes.toString(tableName));

  }

  public void disableTable(final String tableName)

  throws IOException {

    disableTable(Bytes.toBytes(tableName));

  }

  /**

   * Disable table and wait on completion.  May timeout eventually.  Use

   * {@link #disableTableAsync(byte[])} and {@link #isTableDisabled(String)}

   * instead.

   * The table has to be in enabled state for it to be disabled.

   * @param tableName

   * @throws IOException

   * There could be couple types of IOException

   * TableNotFoundException means the table doesn't exist.

   * TableNotEnabledException means the table isn't in enabled state.

   */

  public void disableTable(final byte [] tableName)

  throws IOException {

    disableTableAsync(tableName);

    // Wait until table is disabled

    boolean disabled = false;

    for (int tries = 0; tries < (this.numRetries * this.retryLongerMultiplier); tries++) {

      disabled = isTableDisabled(tableName);

      if (disabled) {

        break;