Admin (Apache HBase 1.4.11 API)

All Superinterfaces:

Abortable, AutoCloseable, Closeable

All Known Implementing Classes:

HBaseAdmin
```
@InterfaceAudience.Public
@InterfaceStability.Evolving
public interface Admin
extends Abortable, Closeable
```
The administrative API for HBase. Obtain an instance from an Connection.getAdmin() and call close() afterwards.
Admin can be used to create, drop, list, enable and disable tables, add and drop table column families and other administrative operations.

Since:

0.99.0

See Also:
ConnectionFactory, Connection, Table

Nested Class Summary

Nested Classes
Modifier and Type Interface and Description

static class Admin.MasterSwitchType
Deprecated.

Nested Classes
Modifier and Type	Interface and Description
`static class`	`Admin.MasterSwitchType` Deprecated.

Method Summary

Methods
Modifier and Type	Method and Description
`void`	`abort(String why, Throwable e)` Abort the server or client.
`boolean`	`abortProcedure(long procId, boolean mayInterruptIfRunning)` abort a procedure
`Future<Boolean>`	`abortProcedureAsync(long procId, boolean mayInterruptIfRunning)` Abort a procedure but does not block and wait for it be completely removed.
`void`	`addColumn(TableName tableName, HColumnDescriptor column)` Add a column to an existing table.
`void`	`assign(byte[] regionName)`
`boolean`	`balancer()` Invoke the balancer.
`boolean`	`balancer(boolean force)` Invoke the balancer.
`List<ServerName>`	`clearDeadServers(List<ServerName> servers)` Clear dead region servers from master.
`void`	`cloneSnapshot(byte[] snapshotName, TableName tableName)` Create a new table by cloning the snapshot content.
`void`	`cloneSnapshot(String snapshotName, TableName tableName)` Create a new table by cloning the snapshot content.
`void`	`cloneSnapshot(String snapshotName, TableName tableName, boolean restoreAcl)` Create a new table by cloning the snapshot content.
`void`	`close()`
`void`	`closeRegion(byte[] regionname, String serverName)` Close a region.
`void`	`closeRegion(ServerName sn, HRegionInfo hri)` Close a region.
`void`	`closeRegion(String regionname, String serverName)` Close a region.
`boolean`	`closeRegionWithEncodedRegionName(String encodedRegionName, String serverName)` For expert-admins.
`void`	`compact(TableName tableName)` Compact a table.
`void`	`compact(TableName tableName, byte[] columnFamily)` Compact a column family within a table.
`void`	`compactRegion(byte[] regionName)` Compact an individual region.
`void`	`compactRegion(byte[] regionName, byte[] columnFamily)` Compact a column family within a region.
`void`	`compactRegionServer(ServerName sn, boolean major)` Compact all regions on the region server
`CoprocessorRpcChannel`	`coprocessorService()` Creates and returns a `RpcChannel` instance connected to the active master.
`CoprocessorRpcChannel`	`coprocessorService(ServerName sn)` Creates and returns a `RpcChannel` instance connected to the passed region server.
`void`	`createNamespace(NamespaceDescriptor descriptor)` Create a new namespace
`void`	`createTable(HTableDescriptor desc)` Creates a new table.
`void`	`createTable(HTableDescriptor desc, byte[][] splitKeys)` Creates a new table with an initial set of empty regions defined by the specified split keys.
`void`	`createTable(HTableDescriptor desc, byte[] startKey, byte[] endKey, int numRegions)` Creates a new table with the specified number of regions.
`void`	`createTableAsync(HTableDescriptor desc, byte[][] splitKeys)` Creates a new table but does not block and wait for it to come online.
`void`	`deleteColumn(TableName tableName, byte[] columnName)` Delete a column from a table.
`void`	`deleteNamespace(String name)` Delete an existing namespace.
`void`	`deleteSnapshot(byte[] snapshotName)` Delete an existing snapshot.
`void`	`deleteSnapshot(String snapshotName)` Delete an existing snapshot.
`void`	`deleteSnapshots(Pattern pattern)` Delete existing snapshots whose names match the pattern passed.
`void`	`deleteSnapshots(String regex)` Delete existing snapshots whose names match the pattern passed.
`void`	`deleteTable(TableName tableName)` Deletes a table.
`HTableDescriptor[]`	`deleteTables(Pattern pattern)` Delete tables matching the passed in pattern and wait on completion.
`HTableDescriptor[]`	`deleteTables(String regex)` Deletes tables matching the passed in pattern and wait on completion.
`void`	`deleteTableSnapshots(Pattern tableNamePattern, Pattern snapshotNamePattern)` Delete all existing snapshots matching the given table name regular expression and snapshot name regular expression.
`void`	`deleteTableSnapshots(String tableNameRegex, String snapshotNameRegex)` Delete all existing snapshots matching the given table name regular expression and snapshot name regular expression.
`void`	`disableTable(TableName tableName)` Disable table and wait on completion.
`void`	`disableTableAsync(TableName tableName)` Starts the disable of a table.
`HTableDescriptor[]`	`disableTables(Pattern pattern)` Disable tables matching the passed in pattern and wait on completion.
`HTableDescriptor[]`	`disableTables(String regex)` Disable tables matching the passed in pattern and wait on completion.
`boolean`	`enableCatalogJanitor(boolean enable)` Enable/Disable the catalog janitor
`void`	`enableTable(TableName tableName)` Enable a table.
`void`	`enableTableAsync(TableName tableName)` Brings a table on-line (enables it).
`HTableDescriptor[]`	`enableTables(Pattern pattern)` Enable tables matching the passed in pattern and wait on completion.
`HTableDescriptor[]`	`enableTables(String regex)` Enable tables matching the passed in pattern and wait on completion.
`void`	`execProcedure(String signature, String instance, Map<String,String> props)` Execute a distributed procedure on a cluster.
`byte[]`	`execProcedureWithRet(String signature, String instance, Map<String,String> props)` Execute a distributed procedure on a cluster.
`void`	`flush(TableName tableName)` Flush a table.
`void`	`flushRegion(byte[] regionName)` Flush an individual region.
`Pair<Integer,Integer>`	`getAlterStatus(byte[] tableName)` Get the status of alter command - indicates how many regions have received the updated schema Asynchronous operation.
`Pair<Integer,Integer>`	`getAlterStatus(TableName tableName)` Get the status of alter command - indicates how many regions have received the updated schema Asynchronous operation.
`ClusterStatus`	`getClusterStatus()`
`org.apache.hadoop.hbase.protobuf.generated.AdminProtos.GetRegionInfoResponse.CompactionState`	`getCompactionState(TableName tableName)` Get the current compaction state of a table.
`org.apache.hadoop.hbase.protobuf.generated.AdminProtos.GetRegionInfoResponse.CompactionState`	`getCompactionStateForRegion(byte[] regionName)` Deprecated.
`org.apache.hadoop.conf.Configuration`	`getConfiguration()`
`Connection`	`getConnection()`
`long`	`getLastMajorCompactionTimestamp(TableName tableName)` Get the timestamp of the last major compaction for the passed table The timestamp of the oldest HFile resulting from a major compaction of that table, or 0 if no such HFile could be found.
`long`	`getLastMajorCompactionTimestampForRegion(byte[] regionName)` Get the timestamp of the last major compaction for the passed region.
`String[]`	`getMasterCoprocessors()` Helper delegage to getClusterStatus().getMasterCoprocessors().
`int`	`getMasterInfoPort()` Get the info port of the current master if one is available.
`NamespaceDescriptor`	`getNamespaceDescriptor(String name)` Get a namespace descriptor by name
`List<HRegionInfo>`	`getOnlineRegions(ServerName sn)` Get all the online regions on a region server.
`int`	`getOperationTimeout()`
`QuotaRetriever`	`getQuotaRetriever(QuotaFilter filter)` Return a QuotaRetriever to list the quotas based on the filter.
`List<SecurityCapability>`	`getSecurityCapabilities()` Return the set of supported security capabilities.
`HTableDescriptor`	`getTableDescriptor(TableName tableName)` Method for getting the tableDescriptor
`HTableDescriptor[]`	`getTableDescriptors(List<String> names)` Get tableDescriptors
`HTableDescriptor[]`	`getTableDescriptorsByTableName(List<TableName> tableNames)` Get tableDescriptors
`List<HRegionInfo>`	`getTableRegions(TableName tableName)` Get the regions of a given table.
`boolean`	`isAborted()` Check if the server or client was aborted.
`boolean`	`isBalancerEnabled()` Query the current state of the balancer
`boolean`	`isCatalogJanitorEnabled()` Query on the catalog janitor state (Enabled/Disabled?)
`boolean`	`isCleanerChoreEnabled()` Query on the cleaner chore state (Enabled/Disabled?)
`boolean`	`isMasterInMaintenanceMode()` Check whether Master is in maintenance mode
`boolean`	`isNormalizerEnabled()` Query the current state of the region normalizer
`boolean`	`isProcedureFinished(String signature, String instance, Map<String,String> props)` Check the current state of the specified procedure.
`boolean`	`isSnapshotFinished(org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.SnapshotDescription snapshot)` Deprecated.
`boolean`	`isSplitOrMergeEnabled(Admin.MasterSwitchType switchType)` Query the current state of the switch
`boolean`	`isTableAvailable(TableName tableName)`
`boolean`	`isTableAvailable(TableName tableName, byte[][] splitKeys)` Use this api to check if the table has been created with the specified number of splitkeys which was used while creating the given table.
`boolean`	`isTableDisabled(TableName tableName)`
`boolean`	`isTableEnabled(TableName tableName)`
`List<ServerName>`	`listDeadServers()` List dead region servers.
`NamespaceDescriptor[]`	`listNamespaceDescriptors()` List available namespace descriptors
`ProcedureInfo[]`	`listProcedures()` List procedures
`List<org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.SnapshotDescription>`	`listSnapshots()` Deprecated.
`List<org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.SnapshotDescription>`	`listSnapshots(Pattern pattern)` Deprecated.
`List<org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.SnapshotDescription>`	`listSnapshots(String regex)` Deprecated.
`HTableDescriptor[]`	`listTableDescriptorsByNamespace(String name)` Get list of table descriptors by namespace
`TableName[]`	`listTableNames()` List all of the names of userspace tables.
`TableName[]`	`listTableNames(Pattern pattern)` List all of the names of userspace tables.
`TableName[]`	`listTableNames(Pattern pattern, boolean includeSysTables)` List all of the names of userspace tables.
`TableName[]`	`listTableNames(String regex)` List all of the names of userspace tables.
`TableName[]`	`listTableNames(String regex, boolean includeSysTables)` List all of the names of userspace tables.
`TableName[]`	`listTableNamesByNamespace(String name)` Get list of table names by namespace
`HTableDescriptor[]`	`listTables()` List all the userspace tables.
`HTableDescriptor[]`	`listTables(Pattern pattern)` List all the userspace tables matching the given pattern.
`HTableDescriptor[]`	`listTables(Pattern pattern, boolean includeSysTables)` List all the tables matching the given pattern.
`HTableDescriptor[]`	`listTables(String regex)` List all the userspace tables matching the given regular expression.
`HTableDescriptor[]`	`listTables(String regex, boolean includeSysTables)` List all the tables matching the given pattern.
`List<org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.SnapshotDescription>`	`listTableSnapshots(Pattern tableNamePattern, Pattern snapshotNamePattern)` Deprecated.
`List<org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.SnapshotDescription>`	`listTableSnapshots(String tableNameRegex, String snapshotNameRegex)` Deprecated.
`void`	`majorCompact(TableName tableName)` Major compact a table.
`void`	`majorCompact(TableName tableName, byte[] columnFamily)` Major compact a column family within a table.
`void`	`majorCompactRegion(byte[] regionName)` Major compact a table or an individual region.
`void`	`majorCompactRegion(byte[] regionName, byte[] columnFamily)` Major compact a column family within region.
`void`	`mergeRegions(byte[] nameOfRegionA, byte[] nameOfRegionB, boolean forcible)` Merge two regions.
`void`	`modifyColumn(TableName tableName, HColumnDescriptor descriptor)` Modify an existing column family on a table.
`void`	`modifyNamespace(NamespaceDescriptor descriptor)` Modify an existing namespace
`void`	`modifyTable(TableName tableName, HTableDescriptor htd)` Modify an existing table, more IRB friendly version.
`void`	`move(byte[] encodedRegionName, byte[] destServerName)` Move the region `r` to `dest`.
`boolean`	`normalize()` Invoke region normalizer.
`void`	`offline(byte[] regionName)` Offline specified region from master's in-memory state.
`void`	`restoreSnapshot(byte[] snapshotName)` Restore the specified snapshot on the original table.
`void`	`restoreSnapshot(byte[] snapshotName, boolean takeFailSafeSnapshot)` Restore the specified snapshot on the original table.
`void`	`restoreSnapshot(String snapshotName)` Restore the specified snapshot on the original table.
`void`	`restoreSnapshot(String snapshotName, boolean takeFailSafeSnapshot)` Restore the specified snapshot on the original table.
`void`	`restoreSnapshot(String snapshotName, boolean takeFailSafeSnapshot, boolean restoreAcl)` Restore the specified snapshot on the original table.
`void`	`rollWALWriter(ServerName serverName)` Roll the log writer.
`int`	`runCatalogScan()` Ask for a scan of the catalog table
`boolean`	`runCleanerChore()` Ask for cleaner chore to run
`boolean`	`setBalancerRunning(boolean on, boolean synchronous)` Turn the load balancer on or off.
`boolean`	`setCleanerChoreRunning(boolean on)` Enable/Disable the cleaner chore
`boolean`	`setNormalizerRunning(boolean on)` Turn region normalizer on or off.
`void`	`setQuota(QuotaSettings quota)` Apply the new quota settings.
`boolean[]`	`setSplitOrMergeEnabled(boolean enabled, boolean synchronous, Admin.MasterSwitchType... switchTypes)` Turn the Split or Merge switches on or off.
`void`	`shutdown()` Shuts down the HBase cluster
`void`	`snapshot(byte[] snapshotName, TableName tableName)` public void snapshot(final String snapshotName, Create a timestamp consistent snapshot for the given table.
`void`	`snapshot(org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.SnapshotDescription snapshot)` Deprecated.
`void`	`snapshot(String snapshotName, TableName tableName)` Take a snapshot for the given table.
`void`	`snapshot(String snapshotName, TableName tableName, org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.SnapshotDescription.Type type)` Deprecated.
`void`	`split(TableName tableName)` Split a table.
`void`	`split(TableName tableName, byte[] splitPoint)` Split a table.
`void`	`splitRegion(byte[] regionName)` Split an individual region.
`void`	`splitRegion(byte[] regionName, byte[] splitPoint)` Split an individual region.
`void`	`stopMaster()` Shuts down the current HBase master only.
`void`	`stopRegionServer(String hostnamePort)` Stop the designated regionserver
`boolean`	`tableExists(TableName tableName)`
`org.apache.hadoop.hbase.protobuf.generated.MasterProtos.SnapshotResponse`	`takeSnapshotAsync(org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.SnapshotDescription snapshot)` Deprecated.
`void`	`truncateTable(TableName tableName, boolean preserveSplits)` Truncate a table.
`void`	`unassign(byte[] regionName, boolean force)` Unassign a region from current hosting regionserver.
`void`	`updateConfiguration()` Update the configuration and trigger an online config change on all the regionservers
`void`	`updateConfiguration(ServerName server)` Update the configuration and trigger an online config change on the regionserver

- Method Detail
  - getOperationTimeout
```
int getOperationTimeout()
```
  - abort
```
void abort(String why,
         Throwable e)
```
    Description copied from interface: Abortable
    
    Abort the server or client.
    
    Specified by:
    
    abort in interface Abortable
    
    Parameters:
    why - Why we're aborting.
    e - Throwable that caused abort. Can be null.
  - isAborted
```
boolean isAborted()
```
    Description copied from interface: Abortable
    
    Check if the server or client was aborted.
    
    Specified by:
    
    isAborted in interface Abortable
    
    Returns:
    true if the server or client was aborted, false otherwise
  - getConnection
```
Connection getConnection()
```
    Returns:
    Connection used by this object.
  - tableExists
```
boolean tableExists(TableName tableName)
                    throws IOException
```
    Parameters:
    tableName - Table to check.
    
    Returns:
    True if table exists already.
    
    Throws:
    
    IOException
  - listTables
```
HTableDescriptor[] listTables()
                              throws IOException
```
    List all the userspace tables.
    
    Returns:
    - returns an array of HTableDescriptors
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - listTables
```
HTableDescriptor[] listTables(Pattern pattern)
                              throws IOException
```
    List all the userspace tables matching the given pattern.
    
    Parameters:
    pattern - The compiled regular expression to match against
    
    Returns:
    - returns an array of HTableDescriptors
    
    Throws:
    
    IOException - if a remote or network exception occurs
    See Also:
    listTables()
  - listTables
```
HTableDescriptor[] listTables(String regex)
                              throws IOException
```
    List all the userspace tables matching the given regular expression.
    
    Parameters:
    regex - The regular expression to match against
    
    Returns:
    - returns an array of HTableDescriptors
    
    Throws:
    
    IOException - if a remote or network exception occurs
    See Also:
    listTables(java.util.regex.Pattern)
  - listTables
```
HTableDescriptor[] listTables(Pattern pattern,
                            boolean includeSysTables)
                              throws IOException
```
    List all the tables matching the given pattern.
    
    Parameters:
    pattern - The compiled regular expression to match against
    includeSysTables - False to match only against userspace tables
    
    Returns:
    - returns an array of HTableDescriptors
    
    Throws:
    
    IOException - if a remote or network exception occurs
    See Also:
    listTables()
  - listTables
```
HTableDescriptor[] listTables(String regex,
                            boolean includeSysTables)
                              throws IOException
```
    List all the tables matching the given pattern.
    
    Parameters:
    regex - The regular expression to match against
    includeSysTables - False to match only against userspace tables
    
    Returns:
    - returns an array of HTableDescriptors
    
    Throws:
    
    IOException - if a remote or network exception occurs
    See Also:
    listTables(java.util.regex.Pattern, boolean)
  - listTableNames
```
TableName[] listTableNames()
                           throws IOException
```
    List all of the names of userspace tables.
    
    Returns:
    TableName[] table names
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - listTableNames
```
TableName[] listTableNames(Pattern pattern)
                           throws IOException
```
    List all of the names of userspace tables.
    
    Parameters:
    pattern - The regular expression to match against
    
    Returns:
    TableName[] table names
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - listTableNames
```
TableName[] listTableNames(String regex)
                           throws IOException
```
    List all of the names of userspace tables.
    
    Parameters:
    regex - The regular expression to match against
    
    Returns:
    TableName[] table names
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - listTableNames
```
TableName[] listTableNames(Pattern pattern,
                         boolean includeSysTables)
                           throws IOException
```
    List all of the names of userspace tables.
    
    Parameters:
    pattern - The regular expression to match against
    includeSysTables - False to match only against userspace tables
    
    Returns:
    TableName[] table names
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - listTableNames
```
TableName[] listTableNames(String regex,
                         boolean includeSysTables)
                           throws IOException
```
    List all of the names of userspace tables.
    
    Parameters:
    regex - The regular expression to match against
    includeSysTables - False to match only against userspace tables
    
    Returns:
    TableName[] table names
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - getTableDescriptor
```
HTableDescriptor getTableDescriptor(TableName tableName)
                                    throws TableNotFoundException,
                                           IOException
```
    Method for getting the tableDescriptor
    
    Parameters:
    tableName - as a TableName
    
    Returns:
    the tableDescriptor
    
    Throws:
    
    TableNotFoundException
    
    IOException - if a remote or network exception occurs
  - createTable
```
void createTable(HTableDescriptor desc)
                 throws IOException
```
    Creates a new table. Synchronous operation.
    
    Parameters:
    desc - table descriptor for table
    
    Throws:
    
    IllegalArgumentException - if the table name is reserved
    
    MasterNotRunningException - if master is not running
    
    TableExistsException - if table already exists (If concurrent threads, the table may have been created between test-for-existence and attempt-at-creation).
    
    IOException - if a remote or network exception occurs
  - createTable
```
void createTable(HTableDescriptor desc,
               byte[] startKey,
               byte[] endKey,
               int numRegions)
                 throws IOException
```
    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.
    
    Parameters:
    desc - table descriptor for table
    startKey - beginning of key range
    endKey - end of key range
    numRegions - the total number of regions to create
    
    Throws:
    
    IllegalArgumentException - if the table name is reserved
    
    MasterNotRunningException - if master is not running
    
    TableExistsException - if table already exists (If concurrent threads, the table may have been created between test-for-existence and attempt-at-creation).
    
    IOException
  - createTable
```
void createTable(HTableDescriptor desc,
               byte[][] splitKeys)
                 throws IOException
```
    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.
    
    Parameters:
    desc - table descriptor for table
    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.
    
    MasterNotRunningException - if master is not running
    
    TableExistsException - if table already exists (If concurrent threads, the table may have been created between test-for-existence and attempt-at-creation).
    
    IOException
  - createTableAsync
```
void createTableAsync(HTableDescriptor desc,
                    byte[][] splitKeys)
                      throws IOException
```
    Creates a new table but does not block and wait for it to come online. Asynchronous operation. To check if the table exists, use isTableAvailable(org.apache.hadoop.hbase.TableName) -- it is not safe to create an HTable instance to this table before it is available. Note : Avoid passing empty split key. Throws IllegalArgumentException Bad table name, if the split keys are repeated and if the split key has empty byte array.
    
    Parameters:
    desc - table descriptor for table
    
    Throws:
    
    MasterNotRunningException - if master is not running
    
    TableExistsException - if table already exists (If concurrent threads, the table may have been created between test-for-existence and attempt-at-creation).
    
    IOException - if a remote or network exception occurs
  - deleteTable
```
void deleteTable(TableName tableName)
                 throws IOException
```
    Deletes a table. Synchronous operation.
    
    Parameters:
    tableName - name of table to delete
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - deleteTables
```
HTableDescriptor[] deleteTables(String regex)
                                throws IOException
```
    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 listTables(java.lang.String) and deleteTable(org.apache.hadoop.hbase.TableName)
    
    Parameters:
    regex - The regular expression to match table names against
    
    Returns:
    Table descriptors for tables that couldn't be deleted
    
    Throws:
    
    IOException
    See Also:
    deleteTables(java.util.regex.Pattern), deleteTable(org.apache.hadoop.hbase.TableName)
  - deleteTables
```
HTableDescriptor[] deleteTables(Pattern pattern)
                                throws IOException
```
    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 listTables(java.util.regex.Pattern) and deleteTable(org.apache.hadoop.hbase.TableName)
    
    Parameters:
    pattern - The pattern to match table names against
    
    Returns:
    Table descriptors for tables that couldn't be deleted
    
    Throws:
    
    IOException
  - truncateTable
```
void truncateTable(TableName tableName,
                 boolean preserveSplits)
                   throws IOException
```
    Truncate a table. Synchronous operation.
    
    Parameters:
    tableName - name of table to truncate
    preserveSplits - True if the splits should be preserved
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - enableTable
```
void enableTable(TableName tableName)
                 throws IOException
```
    Enable a table. May timeout. Use enableTableAsync(org.apache.hadoop.hbase.TableName) and isTableEnabled(org.apache.hadoop.hbase.TableName) instead. The table has to be in disabled state for it to be enabled.
    
    Parameters:
    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 Also:
    isTableEnabled(org.apache.hadoop.hbase.TableName), disableTable(org.apache.hadoop.hbase.TableName), enableTableAsync(org.apache.hadoop.hbase.TableName)
  - enableTableAsync
```
void enableTableAsync(TableName tableName)
                      throws IOException
```
    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 isTableEnabled(org.apache.hadoop.hbase.TableName) to learn when table is fully online. If table is taking too long to online, check server logs.
    
    Parameters:
    tableName -
    
    Throws:
    
    IOException
    Since:
    
    0.90.0
  - enableTables
```
HTableDescriptor[] enableTables(String regex)
                                throws IOException
```
    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 listTables(java.lang.String) and enableTable(org.apache.hadoop.hbase.TableName)
    
    Parameters:
    regex - The regular expression to match table names against
    
    Throws:
    
    IOException
    See Also:
    enableTables(java.util.regex.Pattern), enableTable(org.apache.hadoop.hbase.TableName)
  - enableTables
```
HTableDescriptor[] enableTables(Pattern pattern)
                                throws IOException
```
    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 listTables(java.util.regex.Pattern) and enableTable(org.apache.hadoop.hbase.TableName)
    
    Parameters:
    pattern - The pattern to match table names against
    
    Throws:
    
    IOException
  - disableTableAsync
```
void disableTableAsync(TableName tableName)
                       throws IOException
```
    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 isTableDisabled(org.apache.hadoop.hbase.TableName) to check for when disable completes. If table is taking too long to online, check server logs.
    
    Parameters:
    tableName - name of table
    
    Throws:
    
    IOException - if a remote or network exception occurs
    Since:
    
    0.90.0
    
    See Also:
    isTableDisabled(org.apache.hadoop.hbase.TableName), isTableEnabled(org.apache.hadoop.hbase.TableName)
  - disableTable
```
void disableTable(TableName tableName)
                  throws IOException
```
    Disable table and wait on completion. May timeout eventually. Use disableTableAsync(org.apache.hadoop.hbase.TableName) and isTableDisabled(org.apache.hadoop.hbase.TableName) instead. The table has to be in enabled state for it to be disabled.
    
    Parameters:
    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.
  - disableTables
```
HTableDescriptor[] disableTables(String regex)
                                 throws IOException
```
    Disable 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 listTables(java.lang.String) and disableTable(org.apache.hadoop.hbase.TableName)
    
    Parameters:
    regex - The regular expression to match table names against
    
    Returns:
    Table descriptors for tables that couldn't be disabled
    
    Throws:
    
    IOException
    See Also:
    disableTables(java.util.regex.Pattern), disableTable(org.apache.hadoop.hbase.TableName)
  - disableTables
```
HTableDescriptor[] disableTables(Pattern pattern)
                                 throws IOException
```
    Disable 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 listTables(java.util.regex.Pattern) and disableTable(org.apache.hadoop.hbase.TableName)
    
    Parameters:
    pattern - The pattern to match table names against
    
    Returns:
    Table descriptors for tables that couldn't be disabled
    
    Throws:
    
    IOException
  - isTableEnabled
```
boolean isTableEnabled(TableName tableName)
                       throws IOException
```
    Parameters:
    tableName - name of table to check
    
    Returns:
    true if table is on-line
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - isTableDisabled
```
boolean isTableDisabled(TableName tableName)
                        throws IOException
```
    Parameters:
    tableName - name of table to check
    
    Returns:
    true if table is off-line
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - isTableAvailable
```
boolean isTableAvailable(TableName tableName)
                         throws IOException
```
    Parameters:
    tableName - name of table to check
    
    Returns:
    true if all regions of the table are available
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - isTableAvailable
```
boolean isTableAvailable(TableName tableName,
                       byte[][] splitKeys)
                         throws IOException
```
    Use this api to check if the table has been created with the specified number of splitkeys which was used while creating the given table. Note : If this api is used after a table's region gets splitted, the api may return false.
    
    Parameters:
    tableName - name of table to check
    splitKeys - keys to check if the table has been created with all split keys
    
    Throws:
    
    IOException - if a remote or network excpetion occurs
  - getAlterStatus
```
Pair<Integer,Integer> getAlterStatus(TableName tableName)
                                     throws IOException
```
    Get the status of alter command - indicates how many regions have received the updated schema Asynchronous operation.
    
    Parameters:
    tableName - TableName instance
    
    Returns:
    Pair indicating the number of regions updated Pair.getFirst() is the regions that are yet to be updated Pair.getSecond() is the total number of regions of the table
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - getAlterStatus
```
Pair<Integer,Integer> getAlterStatus(byte[] tableName)
                                     throws IOException
```
    Get the status of alter command - indicates how many regions have received the updated schema Asynchronous operation.
    
    Parameters:
    tableName - name of the table to get the status of
    
    Returns:
    Pair indicating the number of regions updated Pair.getFirst() is the regions that are yet to be updated Pair.getSecond() is the total number of regions of the table
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - addColumn
```
void addColumn(TableName tableName,
             HColumnDescriptor column)
               throws IOException
```
    Add a column to an existing table. Asynchronous operation.
    
    Parameters:
    tableName - name of the table to add column to
    column - column descriptor of column to be added
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - deleteColumn
```
void deleteColumn(TableName tableName,
                byte[] columnName)
                  throws IOException
```
    Delete a column from a table. Asynchronous operation.
    
    Parameters:
    tableName - name of table
    columnName - name of column to be deleted
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - modifyColumn
```
void modifyColumn(TableName tableName,
                HColumnDescriptor descriptor)
                  throws IOException
```
    Modify an existing column family on a table. Asynchronous operation.
    
    Parameters:
    tableName - name of table
    descriptor - new column descriptor to use
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - closeRegion
```
void closeRegion(String regionname,
               String serverName)
                 throws IOException
```
    Close a region. For expert-admins. Runs close on the regionserver. The master will not be informed of the close.
    
    Parameters:
    regionname - region name to close
    serverName - If supplied, we'll use this location rather than the one currently in hbase:meta
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - closeRegion
```
void closeRegion(byte[] regionname,
               String serverName)
                 throws IOException
```
    Close a region. For expert-admins Runs close on the regionserver. The master will not be informed of the close.
    
    Parameters:
    regionname - region name to close
    serverName - The servername of the regionserver. If passed null we will use servername found in the hbase:meta table. A server name is made of host, port and startcode. Here is an example: host187.example.com,60020,1289493121758
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - closeRegionWithEncodedRegionName
```
boolean closeRegionWithEncodedRegionName(String encodedRegionName,
                                       String serverName)
                                         throws IOException
```
    For expert-admins. Runs close on the regionserver. Closes a region based on the encoded region name. The region server name is mandatory. If the servername is provided then based on the online regions in the specified regionserver the specified region will be closed. The master will not be informed of the close. Note that the regionname is the encoded regionname.
    
    Parameters:
    encodedRegionName - The encoded region name; i.e. the hash that makes up the region name suffix: e.g. if regionname is TestTable,0094429456,1289497600452.527db22f95c8a9e0116f0cc13c680396., then the encoded region name is: 527db22f95c8a9e0116f0cc13c680396.
    serverName - The servername of the regionserver. A server name is made of host, port and startcode. This is mandatory. Here is an example: host187.example.com,60020,1289493121758
    
    Returns:
    true if the region was closed, false if not.
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - closeRegion
```
void closeRegion(ServerName sn,
               HRegionInfo hri)
                 throws IOException
```
    Close a region. For expert-admins Runs close on the regionserver. The master will not be informed of the close.
    
    Parameters:
    sn -
    hri -
    
    Throws:
    
    IOException
  - getOnlineRegions
```
List<HRegionInfo> getOnlineRegions(ServerName sn)
                                   throws IOException
```
    Get all the online regions on a region server.
    
    Throws:
    
    IOException
  - flush
```
void flush(TableName tableName)
           throws IOException
```
    Flush a table. Synchronous operation.
    
    Parameters:
    tableName - table to flush
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - flushRegion
```
void flushRegion(byte[] regionName)
                 throws IOException
```
    Flush an individual region. Synchronous operation.
    
    Parameters:
    regionName - region to flush
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - compact
```
void compact(TableName tableName)
             throws IOException
```
    Compact a table. Asynchronous operation.
    
    Parameters:
    tableName - table to compact
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - compactRegion
```
void compactRegion(byte[] regionName)
                   throws IOException
```
    Compact an individual region. Asynchronous operation.
    
    Parameters:
    regionName - region to compact
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - compact
```
void compact(TableName tableName,
           byte[] columnFamily)
             throws IOException
```
    Compact a column family within a table. Asynchronous operation.
    
    Parameters:
    tableName - table to compact
    columnFamily - column family within a table
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - compactRegion
```
void compactRegion(byte[] regionName,
                 byte[] columnFamily)
                   throws IOException
```
    Compact a column family within a region. Asynchronous operation.
    
    Parameters:
    regionName - region to compact
    columnFamily - column family within a region
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - majorCompact
```
void majorCompact(TableName tableName)
                  throws IOException
```
    Major compact a table. Asynchronous operation.
    
    Parameters:
    tableName - table to major compact
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - majorCompactRegion
```
void majorCompactRegion(byte[] regionName)
                        throws IOException
```
    Major compact a table or an individual region. Asynchronous operation.
    
    Parameters:
    regionName - region to major compact
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - majorCompact
```
void majorCompact(TableName tableName,
                byte[] columnFamily)
                  throws IOException
```
    Major compact a column family within a table. Asynchronous operation.
    
    Parameters:
    tableName - table to major compact
    columnFamily - column family within a table
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - majorCompactRegion
```
void majorCompactRegion(byte[] regionName,
                      byte[] columnFamily)
                        throws IOException
```
    Major compact a column family within region. Asynchronous operation.
    
    Parameters:
    regionName - egion to major compact
    columnFamily - column family within a region
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - compactRegionServer
```
void compactRegionServer(ServerName sn,
                       boolean major)
                         throws IOException,
                                InterruptedException
```
    Compact all regions on the region server
    
    Parameters:
    sn - the region server name
    major - if it's major compaction
    
    Throws:
    
    IOException
    
    InterruptedException
  - move
```
void move(byte[] encodedRegionName,
        byte[] destServerName)
          throws IOException
```
    Move the region r to dest.
    
    Parameters:
    encodedRegionName - The encoded region name; i.e. the hash that makes up the region name suffix: e.g. if regionname is TestTable,0094429456,1289497600452.527db22f95c8a9e0116f0cc13c680396., then the encoded region name is: 527db22f95c8a9e0116f0cc13c680396.
    destServerName - The servername of the destination regionserver. If passed the empty byte array we'll assign to a random server. A server name is made of host, port and startcode. Here is an example: host187.example.com,60020,1289493121758
    
    Throws:
    
    IOException - if we can't find a region named encodedRegionName
  - assign
```
void assign(byte[] regionName)
            throws IOException
```
    Parameters:
    regionName - Region name to assign.
    
    Throws:
    
    IOException
  - unassign
```
void unassign(byte[] regionName,
            boolean force)
              throws IOException
```
    Unassign a region from current hosting regionserver. Region will then be assigned to a regionserver chosen at random. Region could be reassigned back to the same server. Use move(byte[], byte[]) if you want to control the region movement.
    
    Parameters:
    regionName - Region to unassign. Will clear any existing RegionPlan if one found.
    force - If true, force unassign (Will remove region from regions-in-transition too if present. If results in double assignment use hbck -fix to resolve. To be used by experts).
    
    Throws:
    
    IOException
  - offline
```
void offline(byte[] regionName)
             throws IOException
```
    Offline specified region from master's in-memory state. It will not attempt to reassign the region as in unassign. This API can be used when a region not served by any region server and still online as per Master's in memory state. If this API is incorrectly used on active region then master will loose track of that region. This is a special method that should be used by experts or hbck.
    
    Parameters:
    regionName - Region to offline.
    
    Throws:
    
    IOException
  - setBalancerRunning
```
boolean setBalancerRunning(boolean on,
                         boolean synchronous)
                           throws IOException
```
    Turn the load balancer on or off.
    
    Parameters:
    synchronous - If true, it waits until current balance() call, if outstanding, to return.
    
    Returns:
    Previous balancer value
    
    Throws:
    
    IOException
  - balancer
```
boolean balancer()
                 throws IOException
```
    Invoke the balancer. Will run the balancer and if regions to move, it will go ahead and do the reassignments. Can NOT run for various reasons. Check logs.
    
    Returns:
    True if balancer ran, false otherwise.
    
    Throws:
    
    IOException
  - balancer
```
boolean balancer(boolean force)
                 throws IOException
```
    Invoke the balancer. Will run the balancer and if regions to move, it will go ahead and do the reassignments. If there is region in transition, force parameter of true would still run balancer. Can *not* run for other reasons. Check logs.
    
    Parameters:
    force - whether we should force balance even if there is region in transition
    
    Returns:
    True if balancer ran, false otherwise.
    
    Throws:
    
    IOException
  - isBalancerEnabled
```
boolean isBalancerEnabled()
                          throws IOException
```
    Query the current state of the balancer
    
    Returns:
    true if the balancer is enabled, false otherwise.
    
    Throws:
    
    IOException
  - normalize
```
boolean normalize()
                  throws IOException
```
    Invoke region normalizer. Can NOT run for various reasons. Check logs.
    
    Returns:
    True if region normalizer ran, false otherwise.
    
    Throws:
    
    IOException
  - isNormalizerEnabled
```
boolean isNormalizerEnabled()
                            throws IOException
```
    Query the current state of the region normalizer
    
    Returns:
    true if region normalizer is enabled, false otherwise.
    
    Throws:
    
    IOException
  - setNormalizerRunning
```
boolean setNormalizerRunning(boolean on)
                             throws IOException
```
    Turn region normalizer on or off.
    
    Returns:
    Previous normalizer value
    
    Throws:
    
    IOException
  - enableCatalogJanitor
```
boolean enableCatalogJanitor(boolean enable)
                             throws IOException
```
    Enable/Disable the catalog janitor
    
    Parameters:
    enable - if true enables the catalog janitor
    
    Returns:
    the previous state
    
    Throws:
    
    IOException
  - runCatalogScan
```
int runCatalogScan()
                   throws IOException
```
    Ask for a scan of the catalog table
    
    Returns:
    the number of entries cleaned
    
    Throws:
    
    IOException
  - isCatalogJanitorEnabled
```
boolean isCatalogJanitorEnabled()
                                throws IOException
```
    Query on the catalog janitor state (Enabled/Disabled?)
    
    Throws:
    
    IOException
  - setCleanerChoreRunning
```
boolean setCleanerChoreRunning(boolean on)
                               throws IOException
```
    Enable/Disable the cleaner chore
    
    Parameters:
    on - if true enables the cleaner chore
    
    Returns:
    the previous state
    
    Throws:
    
    IOException
  - runCleanerChore
```
boolean runCleanerChore()
                        throws IOException
```
    Ask for cleaner chore to run
    
    Returns:
    True if cleaner chore ran, false otherwise
    
    Throws:
    
    IOException
  - isCleanerChoreEnabled
```
boolean isCleanerChoreEnabled()
                              throws IOException
```
    Query on the cleaner chore state (Enabled/Disabled?)
    
    Throws:
    
    IOException
  - mergeRegions
```
void mergeRegions(byte[] nameOfRegionA,
                byte[] nameOfRegionB,
                boolean forcible)
                  throws IOException
```
    Merge two regions. Asynchronous operation.
    
    Parameters:
    nameOfRegionA - encoded or full name of region a
    nameOfRegionB - encoded or full name of region b
    forcible - true if do a compulsory merge, otherwise we will only merge two adjacent regions
    
    Throws:
    
    IOException
  - split
```
void split(TableName tableName)
           throws IOException
```
    Split a table. Asynchronous operation.
    
    Parameters:
    tableName - table to split
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - splitRegion
```
void splitRegion(byte[] regionName)
                 throws IOException
```
    Split an individual region. Asynchronous operation.
    
    Parameters:
    regionName - region to split
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - split
```
void split(TableName tableName,
         byte[] splitPoint)
           throws IOException
```
    Split a table. Asynchronous operation.
    
    Parameters:
    tableName - table to split
    splitPoint - the explicit position to split on
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - splitRegion
```
void splitRegion(byte[] regionName,
               byte[] splitPoint)
                 throws IOException
```
    Split an individual region. Asynchronous operation.
    
    Parameters:
    regionName - region to split
    splitPoint - the explicit position to split on
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - modifyTable
```
void modifyTable(TableName tableName,
               HTableDescriptor htd)
                 throws IOException
```
    Modify an existing table, more IRB friendly version. Asynchronous operation. This means that it may be a while before your schema change is updated across all of the table.
    
    Parameters:
    tableName - name of table.
    htd - modified description of the table
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - shutdown
```
void shutdown()
              throws IOException
```
    Shuts down the HBase cluster
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - stopMaster
```
void stopMaster()
                throws IOException
```
    Shuts down the current HBase master only. Does not shutdown the cluster.
    
    Throws:
    
    IOException - if a remote or network exception occurs
    See Also:
    shutdown()
  - isMasterInMaintenanceMode
```
boolean isMasterInMaintenanceMode()
                                  throws IOException
```
    Check whether Master is in maintenance mode
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - stopRegionServer
```
void stopRegionServer(String hostnamePort)
                      throws IOException
```
    Stop the designated regionserver
    
    Parameters:
    hostnamePort - Hostname and port delimited by a : as in example.org:1234
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - getClusterStatus
```
ClusterStatus getClusterStatus()
                               throws IOException
```
    Returns:
    cluster status
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - getConfiguration
```
org.apache.hadoop.conf.Configuration getConfiguration()
```
    Returns:
    Configuration used by the instance.
  - createNamespace
```
void createNamespace(NamespaceDescriptor descriptor)
                     throws IOException
```
    Create a new namespace
    
    Parameters:
    descriptor - descriptor which describes the new namespace
    
    Throws:
    
    IOException
  - modifyNamespace
```
void modifyNamespace(NamespaceDescriptor descriptor)
                     throws IOException
```
    Modify an existing namespace
    
    Parameters:
    descriptor - descriptor which describes the new namespace
    
    Throws:
    
    IOException
  - deleteNamespace
```
void deleteNamespace(String name)
                     throws IOException
```
    Delete an existing namespace. Only empty namespaces (no tables) can be removed.
    
    Parameters:
    name - namespace name
    
    Throws:
    
    IOException
  - getNamespaceDescriptor
```
NamespaceDescriptor getNamespaceDescriptor(String name)
                                           throws NamespaceNotFoundException,
                                                  IOException
```
    Get a namespace descriptor by name
    
    Parameters:
    name - name of namespace descriptor
    
    Returns:
    A descriptor
    
    Throws:
    
    NamespaceNotFoundException
    
    IOException - if a remote or network exception occurs
  - listNamespaceDescriptors
```
NamespaceDescriptor[] listNamespaceDescriptors()
                                               throws IOException
```
    List available namespace descriptors
    
    Returns:
    List of descriptors
    
    Throws:
    
    IOException
  - listTableDescriptorsByNamespace
```
HTableDescriptor[] listTableDescriptorsByNamespace(String name)
                                                   throws IOException
```
    Get list of table descriptors by namespace
    
    Parameters:
    name - namespace name
    
    Returns:
    A descriptor
    
    Throws:
    
    IOException
  - listTableNamesByNamespace
```
TableName[] listTableNamesByNamespace(String name)
                                      throws IOException
```
    Get list of table names by namespace
    
    Parameters:
    name - namespace name
    
    Returns:
    The list of table names in the namespace
    
    Throws:
    
    IOException
  - getTableRegions
```
List<HRegionInfo> getTableRegions(TableName tableName)
                                  throws IOException
```
    Get the regions of a given table.
    
    Parameters:
    tableName - the name of the table
    
    Returns:
    List of HRegionInfo.
    
    Throws:
    
    IOException
  - close
```
void close()
           throws IOException
```
    Specified by:
    
    close in interface AutoCloseable
    
    Specified by:
    
    close in interface Closeable
    
    Throws:
    
    IOException
  - getTableDescriptorsByTableName
```
HTableDescriptor[] getTableDescriptorsByTableName(List<TableName> tableNames)
                                                  throws IOException
```
    Get tableDescriptors
    
    Parameters:
    tableNames - List of table names
    
    Returns:
    HTD[] the tableDescriptor
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - getTableDescriptors
```
HTableDescriptor[] getTableDescriptors(List<String> names)
                                       throws IOException
```
    Get tableDescriptors
    
    Parameters:
    names - List of table names
    
    Returns:
    HTD[] the tableDescriptor
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - abortProcedure
```
boolean abortProcedure(long procId,
                     boolean mayInterruptIfRunning)
                       throws IOException
```
    abort a procedure
    
    Parameters:
    procId - ID of the procedure to abort
    mayInterruptIfRunning - if the proc completed at least one step, should it be aborted?
    
    Returns:
    true if aborted, false if procedure already completed or does not exist
    
    Throws:
    
    IOException
  - listProcedures
```
ProcedureInfo[] listProcedures()
                               throws IOException
```
    List procedures
    
    Returns:
    procedure list
    
    Throws:
    
    IOException
  - abortProcedureAsync
```
Future<Boolean> abortProcedureAsync(long procId,
                                  boolean mayInterruptIfRunning)
                                    throws IOException
```
    Abort a procedure but does not block and wait for it be completely removed. You can use Future.get(long, TimeUnit) to wait on the operation to complete. It may throw ExecutionException if there was an error while executing the operation or TimeoutException in case the wait timeout was not long enough to allow the operation to complete.
    
    Parameters:
    procId - ID of the procedure to abort
    mayInterruptIfRunning - if the proc completed at least one step, should it be aborted?
    
    Returns:
    true if aborted, false if procedure already completed or does not exist
    
    Throws:
    
    IOException
  - rollWALWriter
```
void rollWALWriter(ServerName serverName)
                   throws IOException,
                          FailedLogCloseException
```
    Roll the log writer. I.e. for filesystem based write ahead logs, start writing to a new file. Note that the actual rolling of the log writer is asynchronous and may not be complete when this method returns. As a side effect of this call, the named region server may schedule store flushes at the request of the wal.
    
    Parameters:
    serverName - The servername of the regionserver.
    
    Throws:
    
    IOException - if a remote or network exception occurs
    
    FailedLogCloseException
  - getMasterCoprocessors
```
String[] getMasterCoprocessors()
                               throws IOException
```
    Helper delegage to getClusterStatus().getMasterCoprocessors().
    
    Returns:
    an array of master coprocessors
    
    Throws:
    
    IOException
    See Also:
    ClusterStatus.getMasterCoprocessors()
  - getCompactionState
```
org.apache.hadoop.hbase.protobuf.generated.AdminProtos.GetRegionInfoResponse.CompactionState getCompactionState(TableName tableName)
                                                                                                                throws IOException
```
    Get the current compaction state of a table. It could be in a major compaction, a minor compaction, both, or none.
    
    Parameters:
    tableName - table to examine
    
    Returns:
    the current compaction state
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - getCompactionStateForRegion
```
@Deprecated
org.apache.hadoop.hbase.protobuf.generated.AdminProtos.GetRegionInfoResponse.CompactionState getCompactionStateForRegion(byte[] regionName)
                                                                                                                         throws IOException
```
    Deprecated.
    
    Get the current compaction state of region. It could be in a major compaction, a minor compaction, both, or none.
    
    Parameters:
    regionName - region to examine
    
    Returns:
    the current compaction state
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - getLastMajorCompactionTimestamp
```
long getLastMajorCompactionTimestamp(TableName tableName)
                                     throws IOException
```
    Get the timestamp of the last major compaction for the passed table The timestamp of the oldest HFile resulting from a major compaction of that table, or 0 if no such HFile could be found.
    
    Parameters:
    tableName - table to examine
    
    Returns:
    the last major compaction timestamp or 0
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - getLastMajorCompactionTimestampForRegion
```
long getLastMajorCompactionTimestampForRegion(byte[] regionName)
                                              throws IOException
```
    Get the timestamp of the last major compaction for the passed region. The timestamp of the oldest HFile resulting from a major compaction of that region, or 0 if no such HFile could be found.
    
    Parameters:
    regionName - region to examine
    
    Returns:
    the last major compaction timestamp or 0
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - snapshot
```
void snapshot(String snapshotName,
            TableName tableName)
              throws IOException,
                     SnapshotCreationException,
                     IllegalArgumentException
```
    Take a snapshot for the given table. If the table is enabled, a FLUSH-type snapshot will be taken. If the table is disabled, an offline snapshot is taken. Snapshots are considered unique based on the name of the snapshot. Attempts to take a snapshot with the same name (even a different type or with different parameters) will fail with a SnapshotCreationException indicating the duplicate naming. Snapshot names follow the same naming constraints as tables in HBase. See TableName.isLegalFullyQualifiedTableName(byte[]).
    
    Parameters:
    snapshotName - name of the snapshot to be created
    tableName - name of the table for which snapshot is created
    
    Throws:
    
    IOException - if a remote or network exception occurs
    
    SnapshotCreationException - if snapshot creation failed
    
    IllegalArgumentException - if the snapshot request is formatted incorrectly
  - snapshot
```
void snapshot(byte[] snapshotName,
            TableName tableName)
              throws IOException,
                     SnapshotCreationException,
                     IllegalArgumentException
```
    public void snapshot(final String snapshotName, Create a timestamp consistent snapshot for the given table. final byte[] tableName) throws IOException, Snapshots are considered unique based on the name of the snapshot. Attempts to take a snapshot with the same name (even a different type or with different parameters) will fail with a SnapshotCreationException indicating the duplicate naming. Snapshot names follow the same naming constraints as tables in HBase.
    
    Parameters:
    snapshotName - name of the snapshot to be created
    tableName - name of the table for which snapshot is created
    
    Throws:
    
    IOException - if a remote or network exception occurs
    
    SnapshotCreationException - if snapshot creation failed
    
    IllegalArgumentException - if the snapshot request is formatted incorrectly
  - snapshot
```
@Deprecated
void snapshot(String snapshotName,
                       TableName tableName,
                       org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.SnapshotDescription.Type type)
              throws IOException,
                     SnapshotCreationException,
                     IllegalArgumentException
```
    Deprecated.
    
    Create typed snapshot of the table. Snapshots are considered unique based on the name of the snapshot. Attempts to take a snapshot with the same name (even a different type or with different parameters) will fail with a SnapshotCreationException indicating the duplicate naming. Snapshot names follow the same naming constraints as tables in HBase. See TableName.isLegalFullyQualifiedTableName(byte[]).
    
    Parameters:
    snapshotName - name to give the snapshot on the filesystem. Must be unique from all other snapshots stored on the cluster
    tableName - name of the table to snapshot
    type - type of snapshot to take
    
    Throws:
    
    IOException - we fail to reach the master
    
    SnapshotCreationException - if snapshot creation failed
    
    IllegalArgumentException - if the snapshot request is formatted incorrectly
  - snapshot
```
@Deprecated
void snapshot(org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.SnapshotDescription snapshot)
              throws IOException,
                     SnapshotCreationException,
                     IllegalArgumentException
```
    Deprecated.
    
    Take a snapshot and wait for the server to complete that snapshot (blocking). Only a single snapshot should be taken at a time for an instance of HBase, or results may be undefined (you can tell multiple HBase clusters to snapshot at the same time, but only one at a time for a single cluster). Snapshots are considered unique based on the name of the snapshot. Attempts to take a snapshot with the same name (even a different type or with different parameters) will fail with a SnapshotCreationException indicating the duplicate naming. Snapshot names follow the same naming constraints as tables in HBase. See TableName.isLegalFullyQualifiedTableName(byte[]). You should probably use snapshot(String, org.apache.hadoop.hbase.TableName) or snapshot(byte[], org.apache.hadoop.hbase.TableName) unless you are sure about the type of snapshot that you want to take.
    
    Parameters:
    snapshot - snapshot to take
    
    Throws:
    
    IOException - or we lose contact with the master.
    
    SnapshotCreationException - if snapshot failed to be taken
    
    IllegalArgumentException - if the snapshot request is formatted incorrectly
  - takeSnapshotAsync
```
@Deprecated
org.apache.hadoop.hbase.protobuf.generated.MasterProtos.SnapshotResponse takeSnapshotAsync(org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.SnapshotDescription snapshot)
                                                                                           throws IOException,
                                                                                                  SnapshotCreationException
```
    Deprecated.
    
    Take a snapshot without waiting for the server to complete that snapshot (asynchronous) Only a single snapshot should be taken at a time, or results may be undefined.
    
    Parameters:
    snapshot - snapshot to take
    
    Returns:
    response from the server indicating the max time to wait for the snapshot
    
    Throws:
    
    IOException - if the snapshot did not succeed or we lose contact with the master.
    
    SnapshotCreationException - if snapshot creation failed
    
    IllegalArgumentException - if the snapshot request is formatted incorrectly
  - isSnapshotFinished
```
@Deprecated
boolean isSnapshotFinished(org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.SnapshotDescription snapshot)
                           throws IOException,
                                  HBaseSnapshotException,
                                  UnknownSnapshotException
```
    Deprecated.
    Check the current state of the passed snapshot. There are three possible states:
    1. running - returns false
    2. finished - returns true
    3. finished with error - throws the exception that caused the snapshot to fail
    The cluster only knows about the most recent snapshot. Therefore, if another snapshot has been run/started since the snapshot you are checking, you will receive an UnknownSnapshotException.
    Parameters:
    snapshot - description of the snapshot to check
    
    Returns:
    true if the snapshot is completed, false if the snapshot is still running
    
    Throws:
    
    IOException - if we have a network issue
    
    HBaseSnapshotException - if the snapshot failed
    
    UnknownSnapshotException - if the requested snapshot is unknown
  - restoreSnapshot
```
void restoreSnapshot(byte[] snapshotName)
                     throws IOException,
                            RestoreSnapshotException
```
    Restore the specified snapshot on the original table. (The table must be disabled) If the "hbase.snapshot.restore.take.failsafe.snapshot" configuration property is set to true, a snapshot of the current table is taken before executing the restore operation. In case of restore failure, the failsafe snapshot will be restored. If the restore completes without problem the failsafe snapshot is deleted.
    
    Parameters:
    snapshotName - name of the snapshot to restore
    
    Throws:
    
    IOException - if a remote or network exception occurs
    
    RestoreSnapshotException - if snapshot failed to be restored
    
    IllegalArgumentException - if the restore request is formatted incorrectly
  - restoreSnapshot
```
void restoreSnapshot(String snapshotName)
                     throws IOException,
                            RestoreSnapshotException
```
    Restore the specified snapshot on the original table. (The table must be disabled) If the "hbase.snapshot.restore.take.failsafe.snapshot" configuration property is set to true, a snapshot of the current table is taken before executing the restore operation. In case of restore failure, the failsafe snapshot will be restored. If the restore completes without problem the failsafe snapshot is deleted.
    
    Parameters:
    snapshotName - name of the snapshot to restore
    
    Throws:
    
    IOException - if a remote or network exception occurs
    
    RestoreSnapshotException - if snapshot failed to be restored
    
    IllegalArgumentException - if the restore request is formatted incorrectly
  - restoreSnapshot
```
void restoreSnapshot(byte[] snapshotName,
                   boolean takeFailSafeSnapshot)
                     throws IOException,
                            RestoreSnapshotException
```
    Restore the specified snapshot on the original table. (The table must be disabled) If 'takeFailSafeSnapshot' is set to true, a snapshot of the current table is taken before executing the restore operation. In case of restore failure, the failsafe snapshot will be restored. If the restore completes without problem the failsafe snapshot is deleted. The failsafe snapshot name is configurable by using the property "hbase.snapshot.restore.failsafe.name".
    
    Parameters:
    snapshotName - name of the snapshot to restore
    takeFailSafeSnapshot - true if the failsafe snapshot should be taken
    
    Throws:
    
    IOException - if a remote or network exception occurs
    
    RestoreSnapshotException - if snapshot failed to be restored
    
    IllegalArgumentException - if the restore request is formatted incorrectly
  - restoreSnapshot
```
void restoreSnapshot(String snapshotName,
                   boolean takeFailSafeSnapshot)
                     throws IOException,
                            RestoreSnapshotException
```
    Restore the specified snapshot on the original table. (The table must be disabled) If 'takeFailSafeSnapshot' is set to true, a snapshot of the current table is taken before executing the restore operation. In case of restore failure, the failsafe snapshot will be restored. If the restore completes without problem the failsafe snapshot is deleted. The failsafe snapshot name is configurable by using the property "hbase.snapshot.restore.failsafe.name".
    
    Parameters:
    snapshotName - name of the snapshot to restore
    takeFailSafeSnapshot - true if the failsafe snapshot should be taken
    
    Throws:
    
    IOException - if a remote or network exception occurs
    
    RestoreSnapshotException - if snapshot failed to be restored
    
    IllegalArgumentException - if the restore request is formatted incorrectly
  - restoreSnapshot
```
void restoreSnapshot(String snapshotName,
                   boolean takeFailSafeSnapshot,
                   boolean restoreAcl)
                     throws IOException,
                            RestoreSnapshotException
```
    Restore the specified snapshot on the original table. (The table must be disabled) If 'takeFailSafeSnapshot' is set to true, a snapshot of the current table is taken before executing the restore operation. In case of restore failure, the failsafe snapshot will be restored. If the restore completes without problem the failsafe snapshot is deleted. The failsafe snapshot name is configurable by using the property "hbase.snapshot.restore.failsafe.name".
    
    Parameters:
    snapshotName - name of the snapshot to restore
    takeFailSafeSnapshot - true if the failsafe snapshot should be taken
    restoreAcl - true to restore acl of snapshot into table.
    
    Throws:
    
    IOException - if a remote or network exception occurs
    
    RestoreSnapshotException - if snapshot failed to be restored
    
    IllegalArgumentException - if the restore request is formatted incorrectly
  - cloneSnapshot
```
void cloneSnapshot(byte[] snapshotName,
                 TableName tableName)
                   throws IOException,
                          TableExistsException,
                          RestoreSnapshotException
```
    Create a new table by cloning the snapshot content.
    
    Parameters:
    snapshotName - name of the snapshot to be cloned
    tableName - name of the table where the snapshot will be restored
    
    Throws:
    
    IOException - if a remote or network exception occurs
    
    TableExistsException - if table to be created already exists
    
    RestoreSnapshotException - if snapshot failed to be cloned
    
    IllegalArgumentException - if the specified table has not a valid name
  - cloneSnapshot
```
void cloneSnapshot(String snapshotName,
                 TableName tableName)
                   throws IOException,
                          TableExistsException,
                          RestoreSnapshotException
```
    Create a new table by cloning the snapshot content.
    
    Parameters:
    snapshotName - name of the snapshot to be cloned
    tableName - name of the table where the snapshot will be restored
    
    Throws:
    
    IOException - if a remote or network exception occurs
    
    TableExistsException - if table to be created already exists
    
    RestoreSnapshotException - if snapshot failed to be cloned
    
    IllegalArgumentException - if the specified table has not a valid name
  - cloneSnapshot
```
void cloneSnapshot(String snapshotName,
                 TableName tableName,
                 boolean restoreAcl)
                   throws IOException,
                          TableExistsException,
                          RestoreSnapshotException
```
    Create a new table by cloning the snapshot content.
    
    Parameters:
    snapshotName - name of the snapshot to be cloned
    tableName - name of the table where the snapshot will be restored
    restoreAcl - true to restore acl of snapshot into newly created table
    
    Throws:
    
    IOException - if a remote or network exception occurs
    
    TableExistsException - if table to be created already exists
    
    RestoreSnapshotException - if snapshot failed to be cloned
    
    IllegalArgumentException - if the specified table has not a valid name
  - execProcedure
```
void execProcedure(String signature,
                 String instance,
                 Map<String,String> props)
                   throws IOException
```
    Execute a distributed procedure on a cluster.
    
    Parameters:
    signature - A distributed procedure is uniquely identified by its signature (default the root ZK node name of the procedure).
    instance - The instance name of the procedure. For some procedures, this parameter is optional.
    props - Property/Value pairs of properties passing to the procedure
    
    Throws:
    
    IOException
  - execProcedureWithRet
```
byte[] execProcedureWithRet(String signature,
                          String instance,
                          Map<String,String> props)
                            throws IOException
```
    Execute a distributed procedure on a cluster.
    
    Parameters:
    signature - A distributed procedure is uniquely identified by its signature (default the root ZK node name of the procedure).
    instance - The instance name of the procedure. For some procedures, this parameter is optional.
    props - Property/Value pairs of properties passing to the procedure
    
    Returns:
    data returned after procedure execution. null if no return data.
    
    Throws:
    
    IOException
  - isProcedureFinished
```
boolean isProcedureFinished(String signature,
                          String instance,
                          Map<String,String> props)
                            throws IOException
```
    Check the current state of the specified procedure. There are three possible states:
    1. running - returns false
    2. finished - returns true
    3. finished with error - throws the exception that caused the procedure to fail
    Parameters:
    signature - The signature that uniquely identifies a procedure
    instance - The instance name of the procedure
    props - Property/Value pairs of properties passing to the procedure
    
    Returns:
    true if the specified procedure is finished successfully, false if it is still running
    
    Throws:
    
    IOException - if the specified procedure finished with error
  - listSnapshots
```
@Deprecated
List<org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.SnapshotDescription> listSnapshots()
                                                                                               throws IOException
```
    Deprecated.
    
    List completed snapshots.
    
    Returns:
    a list of snapshot descriptors for completed snapshots
    
    Throws:
    
    IOException - if a network error occurs
  - listSnapshots
```
@Deprecated
List<org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.SnapshotDescription> listSnapshots(String regex)
                                                                                               throws IOException
```
    Deprecated.
    
    List all the completed snapshots matching the given regular expression.
    
    Parameters:
    regex - The regular expression to match against
    
    Returns:
    - returns a List of SnapshotDescription
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - listSnapshots
```
@Deprecated
List<org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.SnapshotDescription> listSnapshots(Pattern pattern)
                                                                                               throws IOException
```
    Deprecated.
    
    List all the completed snapshots matching the given pattern.
    
    Parameters:
    pattern - The compiled regular expression to match against
    
    Returns:
    - returns a List of SnapshotDescription
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - listTableSnapshots
```
@Deprecated
List<org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.SnapshotDescription> listTableSnapshots(String tableNameRegex,
                                                                                                             String snapshotNameRegex)
                                                                                                    throws IOException
```
    Deprecated.
    
    List all the completed snapshots matching the given table name regular expression and snapshot name regular expression.
    
    Parameters:
    tableNameRegex - The table name regular expression to match against
    snapshotNameRegex - The snapshot name regular expression to match against
    
    Returns:
    - returns a List of completed SnapshotDescription
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - listTableSnapshots
```
@Deprecated
List<org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.SnapshotDescription> listTableSnapshots(Pattern tableNamePattern,
                                                                                                             Pattern snapshotNamePattern)
                                                                                                    throws IOException
```
    Deprecated.
    
    List all the completed snapshots matching the given table name regular expression and snapshot name regular expression.
    
    Parameters:
    tableNamePattern - The compiled table name regular expression to match against
    snapshotNamePattern - The compiled snapshot name regular expression to match against
    
    Returns:
    - returns a List of completed SnapshotDescription
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - deleteSnapshot
```
void deleteSnapshot(byte[] snapshotName)
                    throws IOException
```
    Delete an existing snapshot.
    
    Parameters:
    snapshotName - name of the snapshot
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - deleteSnapshot
```
void deleteSnapshot(String snapshotName)
                    throws IOException
```
    Delete an existing snapshot.
    
    Parameters:
    snapshotName - name of the snapshot
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - deleteSnapshots
```
void deleteSnapshots(String regex)
                     throws IOException
```
    Delete existing snapshots whose names match the pattern passed.
    
    Parameters:
    regex - The regular expression to match against
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - deleteSnapshots
```
void deleteSnapshots(Pattern pattern)
                     throws IOException
```
    Delete existing snapshots whose names match the pattern passed.
    
    Parameters:
    pattern - pattern for names of the snapshot to match
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - deleteTableSnapshots
```
void deleteTableSnapshots(String tableNameRegex,
                        String snapshotNameRegex)
                          throws IOException
```
    Delete all existing snapshots matching the given table name regular expression and snapshot name regular expression.
    
    Parameters:
    tableNameRegex - The table name regular expression to match against
    snapshotNameRegex - The snapshot name regular expression to match against
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - deleteTableSnapshots
```
void deleteTableSnapshots(Pattern tableNamePattern,
                        Pattern snapshotNamePattern)
                          throws IOException
```
    Delete all existing snapshots matching the given table name regular expression and snapshot name regular expression.
    
    Parameters:
    tableNamePattern - The compiled table name regular expression to match against
    snapshotNamePattern - The compiled snapshot name regular expression to match against
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - setQuota
```
void setQuota(QuotaSettings quota)
              throws IOException
```
    Apply the new quota settings.
    
    Parameters:
    quota - the quota settings
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - getQuotaRetriever
```
QuotaRetriever getQuotaRetriever(QuotaFilter filter)
                                 throws IOException
```
    Return a QuotaRetriever to list the quotas based on the filter.
    
    Parameters:
    filter - the quota settings filter
    
    Returns:
    the quota retriever
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - coprocessorService
```
CoprocessorRpcChannel coprocessorService()
```
    Creates and returns a RpcChannel instance connected to the active master.
    The obtained RpcChannel instance can be used to access a published coprocessor Service using standard protobuf service invocations:
    CoprocessorRpcChannel channel = myAdmin.coprocessorService(); MyService.BlockingInterface service = MyService.newBlockingStub(channel); MyCallRequest request = MyCallRequest.newBuilder() ... .build(); MyCallResponse response = service.myCall(null, request);
    Returns:
    A MasterCoprocessorRpcChannel instance
  - coprocessorService
```
CoprocessorRpcChannel coprocessorService(ServerName sn)
```
    Creates and returns a RpcChannel instance connected to the passed region server.
    The obtained RpcChannel instance can be used to access a published coprocessor Service using standard protobuf service invocations:
    CoprocessorRpcChannel channel = myAdmin.coprocessorService(serverName); MyService.BlockingInterface service = MyService.newBlockingStub(channel); MyCallRequest request = MyCallRequest.newBuilder() ... .build(); MyCallResponse response = service.myCall(null, request);
    Parameters:
    sn - the server name to which the endpoint call is made
    
    Returns:
    A RegionServerCoprocessorRpcChannel instance
  - updateConfiguration
```
void updateConfiguration(ServerName server)
                         throws IOException
```
    Update the configuration and trigger an online config change on the regionserver
    
    Parameters:
    server - : The server whose config needs to be updated.
    
    Throws:
    
    IOException
  - updateConfiguration
```
void updateConfiguration()
                         throws IOException
```
    Update the configuration and trigger an online config change on all the regionservers
    
    Throws:
    
    IOException
  - getMasterInfoPort
```
int getMasterInfoPort()
                      throws IOException
```
    Get the info port of the current master if one is available.
    
    Returns:
    master info port
    
    Throws:
    
    IOException
  - getSecurityCapabilities
```
List<SecurityCapability> getSecurityCapabilities()
                                                 throws IOException
```
    Return the set of supported security capabilities.
    
    Throws:
    
    IOException
    
    UnsupportedOperationException
  - setSplitOrMergeEnabled
```
boolean[] setSplitOrMergeEnabled(boolean enabled,
                               boolean synchronous,
                               Admin.MasterSwitchType... switchTypes)
                                 throws IOException
```
    Turn the Split or Merge switches on or off.
    
    Parameters:
    enabled - enabled or not
    synchronous - If true, it waits until current split() call, if outstanding, to return.
    switchTypes - switchType list Admin.MasterSwitchType
    
    Returns:
    Previous switch value array
    
    Throws:
    
    IOException
  - isSplitOrMergeEnabled
```
boolean isSplitOrMergeEnabled(Admin.MasterSwitchType switchType)
                              throws IOException
```
    Query the current state of the switch
    
    Returns:
    true if the switch is enabled, false otherwise.
    
    Throws:
    
    IOException
  - listDeadServers
```
List<ServerName> listDeadServers()
                                 throws IOException
```
    List dead region servers.
    
    Returns:
    List of dead region servers.
    
    Throws:
    
    IOException
  - clearDeadServers
```
List<ServerName> clearDeadServers(List<ServerName> servers)
                                  throws IOException
```
    Clear dead region servers from master.
    
    Parameters:
    servers - list of dead region servers.
    
    Returns:
    List of servers that not cleared
    
    Throws:
    
    IOException - if a remote or network exception occurs

Interface Admin

Nested Class Summary

Method Summary

Method Detail

getOperationTimeout

abort

isAborted

getConnection

tableExists

listTables

listTables

listTables

listTables

listTables

listTableNames

listTableNames

listTableNames

listTableNames

listTableNames

getTableDescriptor

createTable

createTable

createTable

createTableAsync

deleteTable

deleteTables

deleteTables

truncateTable

enableTable

enableTableAsync

enableTables

enableTables

disableTableAsync

disableTable

disableTables

disableTables

isTableEnabled

isTableDisabled

isTableAvailable

isTableAvailable

getAlterStatus

getAlterStatus

addColumn

deleteColumn

modifyColumn

closeRegion

closeRegion

closeRegionWithEncodedRegionName

closeRegion

getOnlineRegions

flush

flushRegion

compact

compactRegion

compact

compactRegion

majorCompact

majorCompactRegion

majorCompact

majorCompactRegion

compactRegionServer

move

assign

unassign

offline

setBalancerRunning

balancer

balancer

isBalancerEnabled

normalize

isNormalizerEnabled

setNormalizerRunning

enableCatalogJanitor

runCatalogScan

isCatalogJanitorEnabled

setCleanerChoreRunning

runCleanerChore

isCleanerChoreEnabled

mergeRegions

split