AdminOverAsyncAdmin (Apache HBase 3.0.0-SNAPSHOT API)

java.lang.Object
- org.apache.hadoop.hbase.client.AdminOverAsyncAdmin

All Implemented Interfaces:

Closeable, AutoCloseable, Abortable, Admin
```
@InterfaceAudience.Private
class AdminOverAsyncAdmin
extends Object
implements Admin
```
The Admin implementation which is based on an AsyncAdmin.

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

private static class AdminOverAsyncAdmin.SyncCoprocessorRpcChannelOverAsync

Nested Classes
Modifier and Type	Class and Description
`private static class`	`AdminOverAsyncAdmin.SyncCoprocessorRpcChannelOverAsync`

Field Summary

Fields
Modifier and Type	Field and Description
`private boolean`	`aborted`
`private RawAsyncHBaseAdmin`	`admin`
`private Connection`	`conn`
`private static org.slf4j.Logger`	`LOG`
`private int`	`operationTimeout`
`private int`	`syncWaitTimeout`

Constructor Summary

Constructors
Constructor and Description

AdminOverAsyncAdmin(Connection conn, RawAsyncHBaseAdmin admin)

Constructors
Constructor and Description
`AdminOverAsyncAdmin(Connection conn, RawAsyncHBaseAdmin admin)`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`abort(String why, Throwable e)` Abort the server or client.
`Future<Boolean>`	`abortProcedureAsync(long procId, boolean mayInterruptIfRunning)` Abort a procedure but does not block and wait for completion.
`Future<Void>`	`addColumnFamilyAsync(TableName tableName, ColumnFamilyDescriptor columnFamily)` Add a column family to an existing table.
`Future<Void>`	`addReplicationPeerAsync(String peerId, ReplicationPeerConfig peerConfig, boolean enabled)` Add a new replication peer but does not block and wait for it.
`void`	`assign(byte[] regionName)` Assign a Region.
`boolean`	`balance()` Invoke the balancer.
`boolean`	`balance(boolean force)` Invoke the balancer.
`boolean`	`balancerSwitch(boolean onOrOff, boolean synchronous)` Turn the load balancer on or off.
`boolean`	`catalogJanitorSwitch(boolean onOrOff)` Enable/Disable the catalog janitor/
`boolean`	`cleanerChoreSwitch(boolean onOrOff)` Enable/Disable the cleaner chore.
`CacheEvictionStats`	`clearBlockCache(TableName tableName)` Clear all the blocks corresponding to this table from BlockCache.
`void`	`clearCompactionQueues(ServerName serverName, Set<String> queues)` Clear compacting queues on a regionserver.
`List<ServerName>`	`clearDeadServers(List<ServerName> servers)` Clear dead region servers from master.
`Future<Void>`	`cloneSnapshotAsync(String snapshotName, TableName tableName, boolean restoreAcl)` Create a new table by cloning the snapshot content.
`void`	`cloneTableSchema(TableName tableName, TableName newTableName, boolean preserveSplits)` Create a new table by cloning the existent table schema.
`void`	`close()`
`void`	`compact(TableName tableName)` Compact a table.
`void`	`compact(TableName tableName, byte[] columnFamily)` Compact a column family within a table.
`void`	`compact(TableName tableName, byte[] columnFamily, CompactType compactType)` Compact a column family within a table.
`void`	`compact(TableName tableName, CompactType compactType)` Compact a table.
`Map<ServerName,Boolean>`	`compactionSwitch(boolean switchState, List<String> serverNamesList)` Turn the compaction on or off.
`void`	`compactRegion(byte[] regionName)` Compact an individual region.
`void`	`compactRegion(byte[] regionName, byte[] columnFamily)` Compact a column family within a region.
`void`	`compactRegionServer(ServerName serverName)` Compact all regions on the region server.
`CoprocessorRpcChannel`	`coprocessorService()` Creates and returns a `RpcChannel` instance connected to the active master.
`CoprocessorRpcChannel`	`coprocessorService(ServerName serverName)` Creates and returns a `RpcChannel` instance connected to the passed region server.
`Future<Void>`	`createNamespaceAsync(NamespaceDescriptor descriptor)` Create a new namespace.
`void`	`createTable(TableDescriptor desc, byte[] startKey, byte[] endKey, int numRegions)` Creates a new table with the specified number of regions.
`Future<Void>`	`createTableAsync(TableDescriptor desc)` Creates a new table but does not block and wait for it to come online.
`Future<Void>`	`createTableAsync(TableDescriptor desc, byte[][] splitKeys)` Creates a new table but does not block and wait for it to come online.
`void`	`decommissionRegionServers(List<ServerName> servers, boolean offload)` Mark region server(s) as decommissioned to prevent additional regions from getting assigned to them.
`Future<Void>`	`deleteColumnFamilyAsync(TableName tableName, byte[] columnFamily)` Delete a column family from a table.
`Future<Void>`	`deleteNamespaceAsync(String name)` Delete an existing namespace.
`void`	`deleteSnapshot(String snapshotName)` Delete an existing snapshot.
`void`	`deleteSnapshots(Pattern pattern)` Delete existing snapshots whose names match the pattern passed.
`Future<Void>`	`deleteTableAsync(TableName tableName)` Deletes the table but does not block and wait for it to be completely removed.
`void`	`deleteTableSnapshots(Pattern tableNamePattern, Pattern snapshotNamePattern)` Delete all existing snapshots matching the given table name regular expression and snapshot name regular expression.
`Future<Void>`	`disableReplicationPeerAsync(String peerId)` Disable a replication peer but does not block and wait for it.
`Future<Void>`	`disableTableAsync(TableName tableName)` Disable the table but does not block and wait for it to be completely disabled.
`void`	`disableTableReplication(TableName tableName)` Disable a table's replication switch.
`Future<Void>`	`enableReplicationPeerAsync(String peerId)` Enable a replication peer but does not block and wait for it.
`Future<Void>`	`enableTableAsync(TableName tableName)` Enable the table but does not block and wait for it to be completely enabled.
`void`	`enableTableReplication(TableName tableName)` Enable a table's replication switch.
`boolean`	`exceedThrottleQuotaSwitch(boolean enable)` Switch the exceed throttle quota.
`void`	`execProcedure(String signature, String instance, Map<String,String> props)` Execute a distributed procedure on a cluster.
`byte[]`	`execProcedureWithReturn(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.
`void`	`flushRegionServer(ServerName serverName)` Flush all regions on the region server.
`ClusterMetrics`	`getClusterMetrics(EnumSet<ClusterMetrics.Option> options)` Get cluster status with a set of `ClusterMetrics.Option` to get desired status.
`CompactionState`	`getCompactionState(TableName tableName)` Get the current compaction state of a table.
`CompactionState`	`getCompactionState(TableName tableName, CompactType compactType)` Get the current compaction state of a table.
`CompactionState`	`getCompactionStateForRegion(byte[] regionName)` Get the current compaction state of region.
`org.apache.hadoop.conf.Configuration`	`getConfiguration()`
`Connection`	`getConnection()`
`SpaceQuotaSnapshotView`	`getCurrentSpaceQuotaSnapshot(String namespace)` Returns the Master's view of a quota on the given `namespace` or null if the Master has no quota information on that namespace.
`SpaceQuotaSnapshotView`	`getCurrentSpaceQuotaSnapshot(TableName tableName)` Returns the Master's view of a quota on the given `tableName` or null if the Master has no quota information on that table.
`TableDescriptor`	`getDescriptor(TableName tableName)` Get a table descriptor.
`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`	`getLocks()` Get locks.
`NamespaceDescriptor`	`getNamespaceDescriptor(String name)` Get a namespace descriptor by name.
`int`	`getOperationTimeout()` Return the operation timeout for a rpc call.
`String`	`getProcedures()` Get procedures.
`List<QuotaSettings>`	`getQuota(QuotaFilter filter)` List the quotas based on the filter.
`List<RegionMetrics>`	`getRegionMetrics(ServerName serverName)` Get `RegionMetrics` of all regions hosted on a regionserver.
`List<RegionMetrics>`	`getRegionMetrics(ServerName serverName, TableName tableName)` Get `RegionMetrics` of all regions hosted on a regionserver for a table.
`List<RegionInfo>`	`getRegions(ServerName serverName)` Get all the online regions on a region server.
`List<RegionInfo>`	`getRegions(TableName tableName)` Get the regions of a given table.
`Map<TableName,? extends SpaceQuotaSnapshotView>`	`getRegionServerSpaceQuotaSnapshots(ServerName serverName)` Fetches the observed `SpaceQuotaSnapshotView`s observed by a RegionServer.
`ReplicationPeerConfig`	`getReplicationPeerConfig(String peerId)` Returns the configured ReplicationPeerConfig for the specified peer.
`List<SecurityCapability>`	`getSecurityCapabilities()` Return the set of supported security capabilities.
`Map<TableName,Long>`	`getSpaceQuotaTableSizes()` Fetches the table sizes on the filesystem as tracked by the HBase Master.
`int`	`getSyncWaitTimeout()` Return the blocking wait time for an asynchronous operation.
`List<UserPermission>`	`getUserPermissions(GetUserPermissionsRequest getUserPermissionsRequest)` Get the global/namespace/table permissions for user
`void`	`grant(UserPermission userPermission, boolean mergeExistingPermissions)` Grants user specific permissions
`List<Boolean>`	`hasUserPermissions(String userName, List<Permission> permissions)` Check if the user has specific permissions
`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`	`isMergeEnabled()` Query the current state of the merge switch.
`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`	`isRpcThrottleEnabled()` Get if the rpc throttle is enabled.
`boolean`	`isSnapshotFinished(SnapshotDescription snapshot)` Check the current state of the passed snapshot.
`boolean`	`isSplitEnabled()` Query the current state of the split switch.
`boolean`	`isTableAvailable(TableName tableName)`
`boolean`	`isTableDisabled(TableName tableName)`
`boolean`	`isTableEnabled(TableName tableName)`
`List<ServerName>`	`listDecommissionedRegionServers()` List region servers marked as decommissioned, which can not be assigned regions.
`NamespaceDescriptor[]`	`listNamespaceDescriptors()` List available namespace descriptors
`String[]`	`listNamespaces()` List available namespaces
`List<TableCFs>`	`listReplicatedTableCFs()` Find all table and column families that are replicated from this cluster
`List<ReplicationPeerDescription>`	`listReplicationPeers()` Return a list of replication peers.
`List<ReplicationPeerDescription>`	`listReplicationPeers(Pattern pattern)` Return a list of replication peers.
`List<SnapshotDescription>`	`listSnapshots()` List completed snapshots.
`List<SnapshotDescription>`	`listSnapshots(Pattern pattern)` List all the completed snapshots matching the given pattern.
`List<TableDescriptor>`	`listTableDescriptors()` List all the userspace tables.
`List<TableDescriptor>`	`listTableDescriptors(List<TableName> tableNames)` Get tableDescriptors.
`List<TableDescriptor>`	`listTableDescriptors(Pattern pattern, boolean includeSysTables)` List all the tables matching the given pattern.
`List<TableDescriptor>`	`listTableDescriptorsByNamespace(byte[] name)` Get list of table descriptors by namespace.
`TableName[]`	`listTableNames()` List all of the names of userspace tables.
`TableName[]`	`listTableNames(Pattern pattern, boolean includeSysTables)` List all of the names of userspace tables.
`TableName[]`	`listTableNamesByNamespace(String name)` Get list of table names by namespace.
`List<SnapshotDescription>`	`listTableSnapshots(Pattern tableNamePattern, Pattern snapshotNamePattern)` List all the completed snapshots matching the given table name regular expression and snapshot name regular expression.
`void`	`majorCompact(TableName tableName)` Major compact a table.
`void`	`majorCompact(TableName tableName, byte[] columnFamily)` Major compact a column family within a table.
`void`	`majorCompact(TableName tableName, byte[] columnFamily, CompactType compactType)` Major compact a column family within a table.
`void`	`majorCompact(TableName tableName, CompactType compactType)` Major compact 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`	`majorCompactRegionServer(ServerName serverName)` Major compact all regions on the region server.
`Future<Void>`	`mergeRegionsAsync(byte[][] nameOfRegionsToMerge, boolean forcible)` Merge regions.
`boolean`	`mergeSwitch(boolean enabled, boolean synchronous)` Turn the merge switch on or off.
`Future<Void>`	`modifyColumnFamilyAsync(TableName tableName, ColumnFamilyDescriptor columnFamily)` Modify an existing column family on a table.
`Future<Void>`	`modifyNamespaceAsync(NamespaceDescriptor descriptor)` Modify an existing namespace.
`Future<Void>`	`modifyTableAsync(TableDescriptor td)` Modify an existing table, more IRB (ruby) friendly version.
`void`	`move(byte[] encodedRegionName)` Move the region `encodedRegionName` to a random server.
`void`	`move(byte[] encodedRegionName, ServerName destServerName)` Move the region `encodedRegionName` to `destServerName`.
`boolean`	`normalize()` Invoke region normalizer.
`boolean`	`normalizerSwitch(boolean on)` Turn region normalizer on or off.
`void`	`offline(byte[] regionName)` Offline specified region from master's in-memory state.
`void`	`recommissionRegionServer(ServerName server, List<byte[]> encodedRegionNames)` Remove decommission marker from a region server to allow regions assignments.
`Future<Void>`	`removeReplicationPeerAsync(String peerId)` Remove a replication peer but does not block and wait for it.
`void`	`restoreSnapshot(String snapshotName)` 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`	`revoke(UserPermission userPermission)` Revokes user specific permissions
`void`	`rollWALWriter(ServerName serverName)` Roll the log writer.
`int`	`runCatalogJanitor()` Ask for a scan of the catalog table.
`boolean`	`runCleanerChore()` Ask for cleaner chore to run.
`void`	`setQuota(QuotaSettings quota)` Apply the new quota settings.
`void`	`shutdown()` Shuts down the HBase cluster.
`void`	`snapshot(SnapshotDescription snapshot)` Take a snapshot and wait for the server to complete that snapshot (blocking).
`Future<Void>`	`snapshotAsync(SnapshotDescription snapshot)` Take a snapshot without waiting for the server to complete that snapshot (asynchronous).
`void`	`split(TableName tableName)` Split a table.
`void`	`split(TableName tableName, byte[] splitPoint)` Split a table.
`Future<Void>`	`splitRegionAsync(byte[] regionName)` Split an individual region.
`Future<Void>`	`splitRegionAsync(byte[] regionName, byte[] splitPoint)` Split an individual region.
`boolean`	`splitSwitch(boolean enabled, boolean synchronous)` Turn the split switch on or off.
`void`	`stopMaster()` Shuts down the current HBase master only.
`void`	`stopRegionServer(String hostnamePort)` Stop the designated regionserver.
`boolean`	`switchRpcThrottle(boolean enable)` Switch the rpc throttle enable state.
`boolean`	`tableExists(TableName tableName)`
`Future<Void>`	`transitReplicationPeerSyncReplicationStateAsync(String peerId, SyncReplicationState state)` Transit current cluster to a new state in a synchronous replication peer.
`Future<Void>`	`truncateTableAsync(TableName tableName, boolean preserveSplits)` Truncate the table but does not block and wait for it to be completely enabled.
`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.
`Future<Void>`	`updateReplicationPeerConfigAsync(String peerId, ReplicationPeerConfig peerConfig)` Update the peerConfig for the specified peer but does not block and wait for it.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface org.apache.hadoop.hbase.client.Admin
abortProcedure, addColumnFamily, addReplicationPeer, addReplicationPeer, addReplicationPeerAsync, appendReplicationPeerTableCFs, cloneSnapshot, cloneSnapshot, cloneSnapshotAsync, createNamespace, createTable, createTable, deleteColumnFamily, deleteNamespace, deleteTable, disableReplicationPeer, disableTable, enableReplicationPeer, enableTable, getBackupMasters, getClusterMetrics, getMaster, getMasterCoprocessorNames, getMasterInfoPort, getRegionServers, getReplicationPeerSyncReplicationState, hasUserPermissions, listDeadServers, listTableDescriptors, listTableNames, mergeRegionsAsync, modifyColumnFamily, modifyNamespace, modifyTable, move, removeReplicationPeer, removeReplicationPeerTableCFs, restoreSnapshot, snapshot, snapshot, snapshot, snapshot, transitReplicationPeerSyncReplicationState, truncateTable, updateReplicationPeerConfig

- Field Detail
  - LOG
```
private static final org.slf4j.Logger LOG
```
  - aborted
```
private volatile boolean aborted
```
  - conn
```
private final Connection conn
```
  - admin
```
private final RawAsyncHBaseAdmin admin
```
  - operationTimeout
```
private final int operationTimeout
```
  - syncWaitTimeout
```
private final int syncWaitTimeout
```
- Constructor Detail
  - AdminOverAsyncAdmin
```
public AdminOverAsyncAdmin(Connection conn,
                           RawAsyncHBaseAdmin admin)
```
- Method Detail
  - getOperationTimeout
```
public int getOperationTimeout()
```
    Description copied from interface: Admin
    
    Return the operation timeout for a rpc call.
    
    Specified by:
    
    getOperationTimeout in interface Admin
    
    See Also:
    
    Admin.getSyncWaitTimeout()
  - getSyncWaitTimeout
```
public int getSyncWaitTimeout()
```
    Description copied from interface: Admin
    
    Return the blocking wait time for an asynchronous operation. Can be configured by hbase.client.sync.wait.timeout.msec.
    For several operations, such as createTable, deleteTable, etc, the rpc call will finish right after we schedule a procedure at master side, so the timeout will not be controlled by the above Admin.getOperationTimeout(). And timeout value here tells you how much time we will wait until the procedure at master side is finished.
    In general, you can consider that the implementation for XXXX method is just a XXXXAsync().get(getSyncWaitTimeout(), TimeUnit.MILLISECONDS).
    
    Specified by:
    
    getSyncWaitTimeout in interface Admin
    
    See Also:
    
    Admin.getOperationTimeout()
  - abort
```
public void abort(String why,
                  Throwable e)
```
    Description copied from interface: Abortable
    
    Abort the server or client.
    
    Specified by:
    
    abort in interface Abortable
    
    Specified by:
    
    abort in interface Admin
    
    Parameters:
    
    why - Why we're aborting.
    
    e - Throwable that caused abort. Can be null.
  - isAborted
```
public boolean isAborted()
```
    Description copied from interface: Abortable
    
    Check if the server or client was aborted.
    
    Specified by:
    
    isAborted in interface Abortable
    
    Specified by:
    
    isAborted in interface Admin
    
    Returns:
    
    true if the server or client was aborted, false otherwise
  - getConnection
```
public Connection getConnection()
```
    Specified by:
    
    getConnection in interface Admin
    
    Returns:
    
    Connection used by this object.
  - tableExists
```
public boolean tableExists(TableName tableName)
                    throws IOException
```
    Specified by:
    
    tableExists in interface Admin
    
    Parameters:
    
    tableName - Table to check.
    
    Returns:
    
    true if table exists already.
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - listTableDescriptors
```
public List<TableDescriptor> listTableDescriptors()
                                           throws IOException
```
    Description copied from interface: Admin
    
    List all the userspace tables.
    
    Specified by:
    
    listTableDescriptors in interface Admin
    
    Returns:
    
    a list of TableDescriptors
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - listTableDescriptors
```
public List<TableDescriptor> listTableDescriptors(Pattern pattern,
                                                  boolean includeSysTables)
                                           throws IOException
```
    Description copied from interface: Admin
    
    List all the tables matching the given pattern.
    
    Specified by:
    
    listTableDescriptors in interface Admin
    
    Parameters:
    
    pattern - The compiled regular expression to match against
    
    includeSysTables - false to match only against userspace tables
    
    Returns:
    
    a list of TableDescriptors
    
    Throws:
    
    IOException - if a remote or network exception occurs
    
    See Also:
    
    Admin.listTableDescriptors()
  - listTableNames
```
public TableName[] listTableNames()
                           throws IOException
```
    Description copied from interface: Admin
    
    List all of the names of userspace tables.
    
    Specified by:
    
    listTableNames in interface Admin
    
    Returns:
    
    TableName[] table names
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - listTableNames
```
public TableName[] listTableNames(Pattern pattern,
                                  boolean includeSysTables)
                           throws IOException
```
    Description copied from interface: Admin
    
    List all of the names of userspace tables.
    
    Specified by:
    
    listTableNames in interface Admin
    
    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
  - getDescriptor
```
public TableDescriptor getDescriptor(TableName tableName)
                              throws TableNotFoundException,
                                     IOException
```
    Description copied from interface: Admin
    
    Get a table descriptor.
    
    Specified by:
    
    getDescriptor in interface Admin
    
    Parameters:
    
    tableName - as a TableName
    
    Returns:
    
    the tableDescriptor
    
    Throws:
    
    TableNotFoundException
    
    IOException - if a remote or network exception occurs
  - createTable
```
public void createTable(TableDescriptor desc,
                        byte[] startKey,
                        byte[] endKey,
                        int numRegions)
                 throws IOException
```
    Description copied from interface: Admin
    
    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.
    
    Specified by:
    
    createTable in interface Admin
    
    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:
    
    IOException - if a remote or network exception occurs
    
    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).
  - createTableAsync
```
public Future<Void> createTableAsync(TableDescriptor desc)
                              throws IOException
```
    Description copied from interface: Admin
    
    Creates a new table but does not block and wait for it to come online. 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.
    Throws IllegalArgumentException Bad table name, if the split keys are repeated and if the split key has empty byte array.
    
    Specified by:
    
    createTableAsync in interface Admin
    
    Parameters:
    
    desc - table descriptor for table
    
    Returns:
    
    the result of the async creation. You can use Future.get(long, TimeUnit) to wait on the operation to complete.
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - createTableAsync
```
public Future<Void> createTableAsync(TableDescriptor desc,
                                     byte[][] splitKeys)
                              throws IOException
```
    Description copied from interface: Admin
    
    Creates a new table but does not block and wait for it to come online. 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. Throws IllegalArgumentException Bad table name, if the split keys are repeated and if the split key has empty byte array.
    
    Specified by:
    
    createTableAsync in interface Admin
    
    Parameters:
    
    desc - table descriptor for table
    
    splitKeys - keys to check if the table has been created with all split keys
    
    Returns:
    
    the result of the async creation. You can use Future.get(long, TimeUnit) to wait on the operation to complete.
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - deleteTableAsync
```
public Future<Void> deleteTableAsync(TableName tableName)
                              throws IOException
```
    Description copied from interface: Admin
    
    Deletes the table but does not block and wait for it to 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.
    
    Specified by:
    
    deleteTableAsync in interface Admin
    
    Parameters:
    
    tableName - name of table to delete
    
    Returns:
    
    the result of the async delete. You can use Future.get(long, TimeUnit) to wait on the operation to complete.
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - truncateTableAsync
```
public Future<Void> truncateTableAsync(TableName tableName,
                                       boolean preserveSplits)
                                throws IOException
```
    Description copied from interface: Admin
    
    Truncate the table but does not block and wait for it to be completely enabled. 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.
    
    Specified by:
    
    truncateTableAsync in interface Admin
    
    Parameters:
    
    tableName - name of table to delete
    
    preserveSplits - true if the splits should be preserved
    
    Returns:
    
    the result of the async truncate. You can use Future.get(long, TimeUnit) to wait on the operation to complete.
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - enableTableAsync
```
public Future<Void> enableTableAsync(TableName tableName)
                              throws IOException
```
    Description copied from interface: Admin
    
    Enable the table but does not block and wait for it to be completely enabled. 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.
    
    Specified by:
    
    enableTableAsync in interface Admin
    
    Parameters:
    
    tableName - name of table to delete
    
    Returns:
    
    the result of the async enable. You can use Future.get(long, TimeUnit) to wait on the operation to complete.
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - disableTableAsync
```
public Future<Void> disableTableAsync(TableName tableName)
                               throws IOException
```
    Description copied from interface: Admin
    
    Disable the table but does not block and wait for it to be completely disabled. 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.
    
    Specified by:
    
    disableTableAsync in interface Admin
    
    Parameters:
    
    tableName - name of table to delete
    
    Returns:
    
    the result of the async disable. You can use Future.get(long, TimeUnit) to wait on the operation to complete.
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - isTableEnabled
```
public boolean isTableEnabled(TableName tableName)
                       throws IOException
```
    Specified by:
    
    isTableEnabled in interface Admin
    
    Parameters:
    
    tableName - name of table to check
    
    Returns:
    
    true if table is on-line
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - isTableDisabled
```
public boolean isTableDisabled(TableName tableName)
                        throws IOException
```
    Specified by:
    
    isTableDisabled in interface Admin
    
    Parameters:
    
    tableName - name of table to check
    
    Returns:
    
    true if table is off-line
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - isTableAvailable
```
public boolean isTableAvailable(TableName tableName)
                         throws IOException
```
    Specified by:
    
    isTableAvailable in interface Admin
    
    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
  - addColumnFamilyAsync
```
public Future<Void> addColumnFamilyAsync(TableName tableName,
                                         ColumnFamilyDescriptor columnFamily)
                                  throws IOException
```
    Description copied from interface: Admin
    
    Add a column family to an existing table. Asynchronous operation. 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.
    
    Specified by:
    
    addColumnFamilyAsync in interface Admin
    
    Parameters:
    
    tableName - name of the table to add column family to
    
    columnFamily - column family descriptor of column family to be added
    
    Returns:
    
    the result of the async add column family. You can use Future.get(long, TimeUnit) to wait on the operation to complete.
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - deleteColumnFamilyAsync
```
public Future<Void> deleteColumnFamilyAsync(TableName tableName,
                                            byte[] columnFamily)
                                     throws IOException
```
    Description copied from interface: Admin
    
    Delete a column family from a table. Asynchronous operation. 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.
    
    Specified by:
    
    deleteColumnFamilyAsync in interface Admin
    
    Parameters:
    
    tableName - name of table
    
    columnFamily - name of column family to be deleted
    
    Returns:
    
    the result of the async delete column family. You can use Future.get(long, TimeUnit) to wait on the operation to complete.
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - modifyColumnFamilyAsync
```
public Future<Void> modifyColumnFamilyAsync(TableName tableName,
                                            ColumnFamilyDescriptor columnFamily)
                                     throws IOException
```
    Description copied from interface: Admin
    
    Modify an existing column family on a table. Asynchronous operation. 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.
    
    Specified by:
    
    modifyColumnFamilyAsync in interface Admin
    
    Parameters:
    
    tableName - name of table
    
    columnFamily - new column family descriptor to use
    
    Returns:
    
    the result of the async modify column family. You can use Future.get(long, TimeUnit) to wait on the operation to complete.
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - getRegions
```
public List<RegionInfo> getRegions(ServerName serverName)
                            throws IOException
```
    Description copied from interface: Admin
    
    Get all the online regions on a region server.
    
    Specified by:
    
    getRegions in interface Admin
    
    Returns:
    
    List of RegionInfo
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - flush
```
public void flush(TableName tableName)
           throws IOException
```
    Description copied from interface: Admin
    
    Flush a table. Synchronous operation.
    
    Specified by:
    
    flush in interface Admin
    
    Parameters:
    
    tableName - table to flush
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - flushRegion
```
public void flushRegion(byte[] regionName)
                 throws IOException
```
    Description copied from interface: Admin
    
    Flush an individual region. Synchronous operation.
    
    Specified by:
    
    flushRegion in interface Admin
    
    Parameters:
    
    regionName - region to flush
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - flushRegionServer
```
public void flushRegionServer(ServerName serverName)
                       throws IOException
```
    Description copied from interface: Admin
    
    Flush all regions on the region server. Synchronous operation.
    
    Specified by:
    
    flushRegionServer in interface Admin
    
    Parameters:
    
    serverName - the region server name to flush
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - compact
```
public void compact(TableName tableName)
             throws IOException
```
    Description copied from interface: Admin
    
    Compact a table. Asynchronous operation in that this method requests that a Compaction run and then it returns. It does not wait on the completion of Compaction (it can take a while).
    
    Specified by:
    
    compact in interface Admin
    
    Parameters:
    
    tableName - table to compact
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - compactRegion
```
public void compactRegion(byte[] regionName)
                   throws IOException
```
    Description copied from interface: Admin
    
    Compact an individual region. Asynchronous operation in that this method requests that a Compaction run and then it returns. It does not wait on the completion of Compaction (it can take a while).
    
    Specified by:
    
    compactRegion in interface Admin
    
    Parameters:
    
    regionName - region to compact
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - compact
```
public void compact(TableName tableName,
                    byte[] columnFamily)
             throws IOException
```
    Description copied from interface: Admin
    
    Compact a column family within a table. Asynchronous operation in that this method requests that a Compaction run and then it returns. It does not wait on the completion of Compaction (it can take a while).
    
    Specified by:
    
    compact in interface Admin
    
    Parameters:
    
    tableName - table to compact
    
    columnFamily - column family within a table
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - compactRegion
```
public void compactRegion(byte[] regionName,
                          byte[] columnFamily)
                   throws IOException
```
    Description copied from interface: Admin
    
    Compact a column family within a region. Asynchronous operation in that this method requests that a Compaction run and then it returns. It does not wait on the completion of Compaction (it can take a while).
    
    Specified by:
    
    compactRegion in interface Admin
    
    Parameters:
    
    regionName - region to compact
    
    columnFamily - column family within a region
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - compact
```
public void compact(TableName tableName,
                    CompactType compactType)
             throws IOException,
                    InterruptedException
```
    Description copied from interface: Admin
    
    Compact a table. Asynchronous operation in that this method requests that a Compaction run and then it returns. It does not wait on the completion of Compaction (it can take a while).
    
    Specified by:
    
    compact in interface Admin
    
    Parameters:
    
    tableName - table to compact
    
    compactType - CompactType
    
    Throws:
    
    IOException - if a remote or network exception occurs
    
    InterruptedException
  - compact
```
public void compact(TableName tableName,
                    byte[] columnFamily,
                    CompactType compactType)
             throws IOException,
                    InterruptedException
```
    Description copied from interface: Admin
    
    Compact a column family within a table. Asynchronous operation in that this method requests that a Compaction run and then it returns. It does not wait on the completion of Compaction (it can take a while).
    
    Specified by:
    
    compact in interface Admin
    
    Parameters:
    
    tableName - table to compact
    
    columnFamily - column family within a table
    
    compactType - CompactType
    
    Throws:
    
    IOException - if not a mob column family or if a remote or network exception occurs
    
    InterruptedException
  - majorCompact
```
public void majorCompact(TableName tableName)
                  throws IOException
```
    Description copied from interface: Admin
    
    Major compact a table. Asynchronous operation in that this method requests that a Compaction run and then it returns. It does not wait on the completion of Compaction (it can take a while).
    
    Specified by:
    
    majorCompact in interface Admin
    
    Parameters:
    
    tableName - table to major compact
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - majorCompactRegion
```
public void majorCompactRegion(byte[] regionName)
                        throws IOException
```
    Description copied from interface: Admin
    
    Major compact a table or an individual region. Asynchronous operation in that this method requests that a Compaction run and then it returns. It does not wait on the completion of Compaction (it can take a while).
    
    Specified by:
    
    majorCompactRegion in interface Admin
    
    Parameters:
    
    regionName - region to major compact
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - majorCompact
```
public void majorCompact(TableName tableName,
                         byte[] columnFamily)
                  throws IOException
```
    Description copied from interface: Admin
    
    Major compact a column family within a table. Asynchronous operation in that this method requests that a Compaction run and then it returns. It does not wait on the completion of Compaction (it can take a while).
    
    Specified by:
    
    majorCompact in interface Admin
    
    Parameters:
    
    tableName - table to major compact
    
    columnFamily - column family within a table
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - majorCompactRegion
```
public void majorCompactRegion(byte[] regionName,
                               byte[] columnFamily)
                        throws IOException
```
    Description copied from interface: Admin
    
    Major compact a column family within region. Asynchronous operation in that this method requests that a Compaction run and then it returns. It does not wait on the completion of Compaction (it can take a while).
    
    Specified by:
    
    majorCompactRegion in interface Admin
    
    Parameters:
    
    regionName - egion to major compact
    
    columnFamily - column family within a region
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - majorCompact
```
public void majorCompact(TableName tableName,
                         CompactType compactType)
                  throws IOException,
                         InterruptedException
```
    Description copied from interface: Admin
    
    Major compact a table. Asynchronous operation in that this method requests that a Compaction run and then it returns. It does not wait on the completion of Compaction (it can take a while).
    
    Specified by:
    
    majorCompact in interface Admin
    
    Parameters:
    
    tableName - table to compact
    
    compactType - CompactType
    
    Throws:
    
    IOException - if a remote or network exception occurs
    
    InterruptedException
  - majorCompact
```
public void majorCompact(TableName tableName,
                         byte[] columnFamily,
                         CompactType compactType)
                  throws IOException,
                         InterruptedException
```
    Description copied from interface: Admin
    
    Major compact a column family within a table. Asynchronous operation in that this method requests that a Compaction run and then it returns. It does not wait on the completion of Compaction (it can take a while).
    
    Specified by:
    
    majorCompact in interface Admin
    
    Parameters:
    
    tableName - table to compact
    
    columnFamily - column family within a table
    
    compactType - CompactType
    
    Throws:
    
    IOException - if not a mob column family or if a remote or network exception occurs
    
    InterruptedException
  - compactionSwitch
```
public Map<ServerName,Boolean> compactionSwitch(boolean switchState,
                                                List<String> serverNamesList)
                                         throws IOException
```
    Description copied from interface: Admin
    
    Turn the compaction on or off. Disabling compactions will also interrupt any currently ongoing compactions. This state is ephemeral. The setting will be lost on restart. Compaction can also be enabled/disabled by modifying configuration hbase.regionserver.compaction.enabled in hbase-site.xml.
    
    Specified by:
    
    compactionSwitch in interface Admin
    
    Parameters:
    
    switchState - Set to true to enable, false to disable.
    
    serverNamesList - list of region servers.
    
    Returns:
    
    Previous compaction states for region servers
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - compactRegionServer
```
public void compactRegionServer(ServerName serverName)
                         throws IOException
```
    Description copied from interface: Admin
    
    Compact all regions on the region server. Asynchronous operation in that this method requests that a Compaction run and then it returns. It does not wait on the completion of Compaction (it can take a while).
    
    Specified by:
    
    compactRegionServer in interface Admin
    
    Parameters:
    
    serverName - the region server name
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - majorCompactRegionServer
```
public void majorCompactRegionServer(ServerName serverName)
                              throws IOException
```
    Description copied from interface: Admin
    
    Major compact all regions on the region server. Asynchronous operation in that this method requests that a Compaction run and then it returns. It does not wait on the completion of Compaction (it can take a while).
    
    Specified by:
    
    majorCompactRegionServer in interface Admin
    
    Parameters:
    
    serverName - the region server name
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - move
```
public void move(byte[] encodedRegionName)
          throws IOException
```
    Description copied from interface: Admin
    
    Move the region encodedRegionName to a random server.
    
    Specified by:
    
    move in interface Admin
    
    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.
    
    Throws:
    
    IOException - if we can't find a region named encodedRegionName
  - move
```
public void move(byte[] encodedRegionName,
                 ServerName destServerName)
          throws IOException
```
    Description copied from interface: Admin
    
    Move the region encodedRegionName to destServerName.
    
    Specified by:
    
    move in interface Admin
    
    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. 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
```
public void assign(byte[] regionName)
            throws IOException
```
    Description copied from interface: Admin
    
    Assign a Region.
    
    Specified by:
    
    assign in interface Admin
    
    Parameters:
    
    regionName - Region name to assign.
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - unassign
```
public void unassign(byte[] regionName,
                     boolean force)
              throws IOException
```
    Description copied from interface: Admin
    
    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 Admin.move(byte[], ServerName) if you want to control the region movement.
    
    Specified by:
    
    unassign in interface Admin
    
    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 - if a remote or network exception occurs
  - offline
```
public void offline(byte[] regionName)
             throws IOException
```
    Description copied from interface: Admin
    
    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.
    
    Specified by:
    
    offline in interface Admin
    
    Parameters:
    
    regionName - Region to offline.
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - balancerSwitch
```
public boolean balancerSwitch(boolean onOrOff,
                              boolean synchronous)
                       throws IOException
```
    Description copied from interface: Admin
    
    Turn the load balancer on or off.
    
    Specified by:
    
    balancerSwitch in interface Admin
    
    Parameters:
    
    onOrOff - Set to true to enable, false to disable.
    
    synchronous - If true, it waits until current balance() call, if outstanding, to return.
    
    Returns:
    
    Previous balancer value
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - balance
```
public boolean balance()
                throws IOException
```
    Description copied from interface: Admin
    
    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.
    
    Specified by:
    
    balance in interface Admin
    
    Returns:
    
    true if balancer ran, false otherwise.
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - balance
```
public boolean balance(boolean force)
                throws IOException
```
    Description copied from interface: Admin
    
    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.
    
    Specified by:
    
    balance in interface Admin
    
    Parameters:
    
    force - whether we should force balance even if there is region in transition
    
    Returns:
    
    true if balancer ran, false otherwise.
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - isBalancerEnabled
```
public boolean isBalancerEnabled()
                          throws IOException
```
    Description copied from interface: Admin
    
    Query the current state of the balancer.
    
    Specified by:
    
    isBalancerEnabled in interface Admin
    
    Returns:
    
    true if the balancer is enabled, false otherwise.
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - clearBlockCache
```
public CacheEvictionStats clearBlockCache(TableName tableName)
                                   throws IOException
```
    Description copied from interface: Admin
    
    Clear all the blocks corresponding to this table from BlockCache. For expert-admins. Calling this API will drop all the cached blocks specific to a table from BlockCache. This can significantly impact the query performance as the subsequent queries will have to retrieve the blocks from underlying filesystem.
    
    Specified by:
    
    clearBlockCache in interface Admin
    
    Parameters:
    
    tableName - table to clear block cache
    
    Returns:
    
    CacheEvictionStats related to the eviction
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - normalize
```
public boolean normalize()
                  throws IOException
```
    Description copied from interface: Admin
    
    Invoke region normalizer. Can NOT run for various reasons. Check logs.
    
    Specified by:
    
    normalize in interface Admin
    
    Returns:
    
    true if region normalizer ran, false otherwise.
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - isNormalizerEnabled
```
public boolean isNormalizerEnabled()
                            throws IOException
```
    Description copied from interface: Admin
    
    Query the current state of the region normalizer.
    
    Specified by:
    
    isNormalizerEnabled in interface Admin
    
    Returns:
    
    true if region normalizer is enabled, false otherwise.
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - normalizerSwitch
```
public boolean normalizerSwitch(boolean on)
                         throws IOException
```
    Description copied from interface: Admin
    
    Turn region normalizer on or off.
    
    Specified by:
    
    normalizerSwitch in interface Admin
    
    Returns:
    
    Previous normalizer value
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - catalogJanitorSwitch
```
public boolean catalogJanitorSwitch(boolean onOrOff)
                             throws IOException
```
    Description copied from interface: Admin
    
    Enable/Disable the catalog janitor/
    
    Specified by:
    
    catalogJanitorSwitch in interface Admin
    
    Parameters:
    
    onOrOff - if true enables the catalog janitor
    
    Returns:
    
    the previous state
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - runCatalogJanitor
```
public int runCatalogJanitor()
                      throws IOException
```
    Description copied from interface: Admin
    
    Ask for a scan of the catalog table.
    
    Specified by:
    
    runCatalogJanitor in interface Admin
    
    Returns:
    
    the number of entries cleaned
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - isCatalogJanitorEnabled
```
public boolean isCatalogJanitorEnabled()
                                throws IOException
```
    Description copied from interface: Admin
    
    Query on the catalog janitor state (Enabled/Disabled?).
    
    Specified by:
    
    isCatalogJanitorEnabled in interface Admin
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - cleanerChoreSwitch
```
public boolean cleanerChoreSwitch(boolean onOrOff)
                           throws IOException
```
    Description copied from interface: Admin
    
    Enable/Disable the cleaner chore.
    
    Specified by:
    
    cleanerChoreSwitch in interface Admin
    
    Parameters:
    
    onOrOff - if true enables the cleaner chore
    
    Returns:
    
    the previous state
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - runCleanerChore
```
public boolean runCleanerChore()
                        throws IOException
```
    Description copied from interface: Admin
    
    Ask for cleaner chore to run.
    
    Specified by:
    
    runCleanerChore in interface Admin
    
    Returns:
    
    true if cleaner chore ran, false otherwise
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - isCleanerChoreEnabled
```
public boolean isCleanerChoreEnabled()
                              throws IOException
```
    Description copied from interface: Admin
    
    Query on the cleaner chore state (Enabled/Disabled?).
    
    Specified by:
    
    isCleanerChoreEnabled in interface Admin
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - mergeRegionsAsync
```
public Future<Void> mergeRegionsAsync(byte[][] nameOfRegionsToMerge,
                                      boolean forcible)
                               throws IOException
```
    Description copied from interface: Admin
    
    Merge regions. Asynchronous operation.
    You may get a DoNotRetryIOException if you pass more than two regions in but the master does not support merging more than two regions. At least till 2.2.0, we still only support merging two regions.
    
    Specified by:
    
    mergeRegionsAsync in interface Admin
    
    Parameters:
    
    nameOfRegionsToMerge - encoded or full name of daughter regions
    
    forcible - true if do a compulsory merge, otherwise we will only merge adjacent regions
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - split
```
public void split(TableName tableName)
           throws IOException
```
    Description copied from interface: Admin
    
    Split a table. The method will execute split action for each region in table.
    
    Specified by:
    
    split in interface Admin
    
    Parameters:
    
    tableName - table to split
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - split
```
public void split(TableName tableName,
                  byte[] splitPoint)
           throws IOException
```
    Description copied from interface: Admin
    
    Split a table.
    
    Specified by:
    
    split in interface Admin
    
    Parameters:
    
    tableName - table to split
    
    splitPoint - the explicit position to split on
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - splitRegionAsync
```
public Future<Void> splitRegionAsync(byte[] regionName)
                              throws IOException
```
    Description copied from interface: Admin
    
    Split an individual region. Asynchronous operation.
    
    Specified by:
    
    splitRegionAsync in interface Admin
    
    Parameters:
    
    regionName - region to split
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - splitRegionAsync
```
public Future<Void> splitRegionAsync(byte[] regionName,
                                     byte[] splitPoint)
                              throws IOException
```
    Description copied from interface: Admin
    
    Split an individual region. Asynchronous operation.
    
    Specified by:
    
    splitRegionAsync in interface Admin
    
    Parameters:
    
    regionName - region to split
    
    splitPoint - the explicit position to split on
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - modifyTableAsync
```
public Future<Void> modifyTableAsync(TableDescriptor td)
                              throws IOException
```
    Description copied from interface: Admin
    
    Modify an existing table, more IRB (ruby) friendly version. Asynchronous operation. This means that it may be a while before your schema change is updated across all of the table. 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.
    
    Specified by:
    
    modifyTableAsync in interface Admin
    
    Parameters:
    
    td - description of the table
    
    Returns:
    
    the result of the async modify. You can use Future.get(long, TimeUnit) to wait on the operation to complete
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - shutdown
```
public void shutdown()
              throws IOException
```
    Description copied from interface: Admin
    
    Shuts down the HBase cluster.
    Notice that, a success shutdown call may ends with an error since the remote server has already been shutdown.
    
    Specified by:
    
    shutdown in interface Admin
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - stopMaster
```
public void stopMaster()
                throws IOException
```
    Description copied from interface: Admin
    
    Shuts down the current HBase master only. Does not shutdown the cluster.
    Notice that, a success stopMaster call may ends with an error since the remote server has already been shutdown.
    
    Specified by:
    
    stopMaster in interface Admin
    
    Throws:
    
    IOException - if a remote or network exception occurs
    
    See Also:
    
    Admin.shutdown()
  - isMasterInMaintenanceMode
```
public boolean isMasterInMaintenanceMode()
                                  throws IOException
```
    Description copied from interface: Admin
    
    Check whether Master is in maintenance mode.
    
    Specified by:
    
    isMasterInMaintenanceMode in interface Admin
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - stopRegionServer
```
public void stopRegionServer(String hostnamePort)
                      throws IOException
```
    Description copied from interface: Admin
    
    Stop the designated regionserver.
    
    Specified by:
    
    stopRegionServer in interface Admin
    
    Parameters:
    
    hostnamePort - Hostname and port delimited by a : as in example.org:1234
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - getClusterMetrics
```
public ClusterMetrics getClusterMetrics(EnumSet<ClusterMetrics.Option> options)
                                 throws IOException
```
    Description copied from interface: Admin
    
    Get cluster status with a set of ClusterMetrics.Option to get desired status.
    
    Specified by:
    
    getClusterMetrics in interface Admin
    
    Returns:
    
    cluster status
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - getRegionMetrics
```
public List<RegionMetrics> getRegionMetrics(ServerName serverName)
                                     throws IOException
```
    Description copied from interface: Admin
    
    Get RegionMetrics of all regions hosted on a regionserver.
    
    Specified by:
    
    getRegionMetrics in interface Admin
    
    Parameters:
    
    serverName - region server from which RegionMetrics is required.
    
    Returns:
    
    a RegionMetrics list of all regions hosted on a region server
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - getRegionMetrics
```
public List<RegionMetrics> getRegionMetrics(ServerName serverName,
                                            TableName tableName)
                                     throws IOException
```
    Description copied from interface: Admin
    
    Get RegionMetrics of all regions hosted on a regionserver for a table.
    
    Specified by:
    
    getRegionMetrics in interface Admin
    
    Parameters:
    
    serverName - region server from which RegionMetrics is required.
    
    tableName - get RegionMetrics of regions belonging to the table
    
    Returns:
    
    region metrics map of all regions of a table hosted on a region server
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - getConfiguration
```
public org.apache.hadoop.conf.Configuration getConfiguration()
```
    Specified by:
    
    getConfiguration in interface Admin
    
    Returns:
    
    Configuration used by the instance.
  - createNamespaceAsync
```
public Future<Void> createNamespaceAsync(NamespaceDescriptor descriptor)
                                  throws IOException
```
    Description copied from interface: Admin
    
    Create a new namespace.
    
    Specified by:
    
    createNamespaceAsync in interface Admin
    
    Parameters:
    
    descriptor - descriptor which describes the new namespace
    
    Returns:
    
    the result of the async create namespace operation. Use Future.get(long, TimeUnit) to wait on the operation to complete.
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - modifyNamespaceAsync
```
public Future<Void> modifyNamespaceAsync(NamespaceDescriptor descriptor)
                                  throws IOException
```
    Description copied from interface: Admin
    
    Modify an existing namespace.
    
    Specified by:
    
    modifyNamespaceAsync in interface Admin
    
    Parameters:
    
    descriptor - descriptor which describes the new namespace
    
    Returns:
    
    the result of the async modify namespace operation. Use Future.get(long, TimeUnit) to wait on the operation to complete.
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - deleteNamespaceAsync
```
public Future<Void> deleteNamespaceAsync(String name)
                                  throws IOException
```
    Description copied from interface: Admin
    
    Delete an existing namespace. Only empty namespaces (no tables) can be removed.
    
    Specified by:
    
    deleteNamespaceAsync in interface Admin
    
    Parameters:
    
    name - namespace name
    
    Returns:
    
    the result of the async delete namespace operation. Use Future.get(long, TimeUnit) to wait on the operation to complete.
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - getNamespaceDescriptor
```
public NamespaceDescriptor getNamespaceDescriptor(String name)
                                           throws NamespaceNotFoundException,
                                                  IOException
```
    Description copied from interface: Admin
    
    Get a namespace descriptor by name.
    
    Specified by:
    
    getNamespaceDescriptor in interface Admin
    
    Parameters:
    
    name - name of namespace descriptor
    
    Returns:
    
    A descriptor
    
    Throws:
    
    NamespaceNotFoundException
    
    IOException - if a remote or network exception occurs
  - listNamespaces
```
public String[] listNamespaces()
                        throws IOException
```
    Description copied from interface: Admin
    
    List available namespaces
    
    Specified by:
    
    listNamespaces in interface Admin
    
    Returns:
    
    List of namespace names
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - listNamespaceDescriptors
```
public NamespaceDescriptor[] listNamespaceDescriptors()
                                               throws IOException
```
    Description copied from interface: Admin
    
    List available namespace descriptors
    
    Specified by:
    
    listNamespaceDescriptors in interface Admin
    
    Returns:
    
    List of descriptors
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - listTableDescriptorsByNamespace
```
public List<TableDescriptor> listTableDescriptorsByNamespace(byte[] name)
                                                      throws IOException
```
    Description copied from interface: Admin
    
    Get list of table descriptors by namespace.
    
    Specified by:
    
    listTableDescriptorsByNamespace in interface Admin
    
    Parameters:
    
    name - namespace name
    
    Returns:
    
    returns a list of TableDescriptors
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - listTableNamesByNamespace
```
public TableName[] listTableNamesByNamespace(String name)
                                      throws IOException
```
    Description copied from interface: Admin
    
    Get list of table names by namespace.
    
    Specified by:
    
    listTableNamesByNamespace in interface Admin
    
    Parameters:
    
    name - namespace name
    
    Returns:
    
    The list of table names in the namespace
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - getRegions
```
public List<RegionInfo> getRegions(TableName tableName)
                            throws IOException
```
    Description copied from interface: Admin
    
    Get the regions of a given table.
    
    Specified by:
    
    getRegions in interface Admin
    
    Parameters:
    
    tableName - the name of the table
    
    Returns:
    
    List of RegionInfo.
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - close
```
public void close()
```
    Specified by:
    
    close in interface Closeable
    
    Specified by:
    
    close in interface AutoCloseable
    
    Specified by:
    
    close in interface Admin
  - listTableDescriptors
```
public List<TableDescriptor> listTableDescriptors(List<TableName> tableNames)
                                           throws IOException
```
    Description copied from interface: Admin
    
    Get tableDescriptors.
    
    Specified by:
    
    listTableDescriptors in interface Admin
    
    Parameters:
    
    tableNames - List of table names
    
    Returns:
    
    returns a list of TableDescriptors
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - abortProcedureAsync
```
public Future<Boolean> abortProcedureAsync(long procId,
                                           boolean mayInterruptIfRunning)
                                    throws IOException
```
    Description copied from interface: Admin
    
    Abort a procedure but does not block and wait for completion. 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. Do not use. Usually it is ignored but if not, it can do more damage than good. See hbck2.
    
    Specified by:
    
    abortProcedureAsync in interface Admin
    
    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 - if a remote or network exception occurs
    
    See Also:
    
    HBASE-21223
  - getProcedures
```
public String getProcedures()
                     throws IOException
```
    Description copied from interface: Admin
    
    Get procedures.
    
    Specified by:
    
    getProcedures in interface Admin
    
    Returns:
    
    procedure list in JSON
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - getLocks
```
public String getLocks()
                throws IOException
```
    Description copied from interface: Admin
    
    Get locks.
    
    Specified by:
    
    getLocks in interface Admin
    
    Returns:
    
    lock list in JSON
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - rollWALWriter
```
public void rollWALWriter(ServerName serverName)
                   throws IOException,
                          FailedLogCloseException
```
    Description copied from interface: Admin
    
    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.
    
    Specified by:
    
    rollWALWriter in interface Admin
    
    Parameters:
    
    serverName - The servername of the regionserver.
    
    Throws:
    
    IOException - if a remote or network exception occurs
    
    FailedLogCloseException
  - getCompactionState
```
public CompactionState getCompactionState(TableName tableName)
                                   throws IOException
```
    Description copied from interface: Admin
    
    Get the current compaction state of a table. It could be in a major compaction, a minor compaction, both, or none.
    
    Specified by:
    
    getCompactionState in interface Admin
    
    Parameters:
    
    tableName - table to examine
    
    Returns:
    
    the current compaction state
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - getCompactionState
```
public CompactionState getCompactionState(TableName tableName,
                                          CompactType compactType)
                                   throws IOException
```
    Description copied from interface: Admin
    
    Get the current compaction state of a table. It could be in a compaction, or none.
    
    Specified by:
    
    getCompactionState in interface Admin
    
    Parameters:
    
    tableName - table to examine
    
    compactType - CompactType
    
    Returns:
    
    the current compaction state
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - getCompactionStateForRegion
```
public CompactionState getCompactionStateForRegion(byte[] regionName)
                                            throws IOException
```
    Description copied from interface: Admin
    
    Get the current compaction state of region. It could be in a major compaction, a minor compaction, both, or none.
    
    Specified by:
    
    getCompactionStateForRegion in interface Admin
    
    Parameters:
    
    regionName - region to examine
    
    Returns:
    
    the current compaction state
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - getLastMajorCompactionTimestamp
```
public long getLastMajorCompactionTimestamp(TableName tableName)
                                     throws IOException
```
    Description copied from interface: Admin
    
    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.
    
    Specified by:
    
    getLastMajorCompactionTimestamp in interface Admin
    
    Parameters:
    
    tableName - table to examine
    
    Returns:
    
    the last major compaction timestamp or 0
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - getLastMajorCompactionTimestampForRegion
```
public long getLastMajorCompactionTimestampForRegion(byte[] regionName)
                                              throws IOException
```
    Description copied from interface: Admin
    
    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.
    
    Specified by:
    
    getLastMajorCompactionTimestampForRegion in interface Admin
    
    Parameters:
    
    regionName - region to examine
    
    Returns:
    
    the last major compaction timestamp or 0
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - snapshot
```
public void snapshot(SnapshotDescription snapshot)
              throws IOException,
                     SnapshotCreationException,
                     IllegalArgumentException
```
    Description copied from interface: Admin
    
    Take a snapshot and wait for the server to complete that snapshot (blocking). Snapshots are considered unique based on the name of the snapshot. Snapshots are taken sequentially even when requested concurrently, across all tables. 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 Admin.snapshot(String, org.apache.hadoop.hbase.TableName) unless you are sure about the type of snapshot that you want to take.
    
    Specified by:
    
    snapshot in interface Admin
    
    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
  - snapshotAsync
```
public Future<Void> snapshotAsync(SnapshotDescription snapshot)
                           throws IOException,
                                  SnapshotCreationException
```
    Description copied from interface: Admin
    
    Take a snapshot without waiting for the server to complete that snapshot (asynchronous). Snapshots are considered unique based on the name of the snapshot. Snapshots are taken sequentially even when requested concurrently, across all tables.
    
    Specified by:
    
    snapshotAsync in interface Admin
    
    Parameters:
    
    snapshot - snapshot to take
    
    Throws:
    
    IOException - if the snapshot did not succeed or we lose contact with the master.
    
    SnapshotCreationException - if snapshot creation failed
  - isSnapshotFinished
```
public boolean isSnapshotFinished(SnapshotDescription snapshot)
                           throws IOException,
                                  HBaseSnapshotException,
                                  UnknownSnapshotException
```
    Description copied from interface: Admin
    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.
    Specified by:
    
    isSnapshotFinished in interface Admin
    
    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
```
public void restoreSnapshot(String snapshotName)
                     throws IOException,
                            RestoreSnapshotException
```
    Description copied from interface: Admin
    
    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.
    
    Specified by:
    
    restoreSnapshot in interface Admin
    
    Parameters:
    
    snapshotName - name of the snapshot to restore
    
    Throws:
    
    IOException - if a remote or network exception occurs
    
    RestoreSnapshotException - if snapshot failed to be restored
  - restoreSnapshot
```
public void restoreSnapshot(String snapshotName,
                            boolean takeFailSafeSnapshot,
                            boolean restoreAcl)
                     throws IOException,
                            RestoreSnapshotException
```
    Description copied from interface: Admin
    
    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".
    
    Specified by:
    
    restoreSnapshot in interface Admin
    
    Parameters:
    
    snapshotName - name of the snapshot to restore
    
    takeFailSafeSnapshot - true if the failsafe snapshot should be taken
    
    restoreAcl - true to restore acl of snapshot
    
    Throws:
    
    IOException - if a remote or network exception occurs
    
    RestoreSnapshotException - if snapshot failed to be restored
  - cloneSnapshotAsync
```
public Future<Void> cloneSnapshotAsync(String snapshotName,
                                       TableName tableName,
                                       boolean restoreAcl)
                                throws IOException,
                                       TableExistsException,
                                       RestoreSnapshotException
```
    Description copied from interface: Admin
    
    Create a new table by cloning the snapshot content.
    
    Specified by:
    
    cloneSnapshotAsync in interface Admin
    
    Parameters:
    
    snapshotName - name of the snapshot to be cloned
    
    tableName - name of the table where the snapshot will be restored
    
    restoreAcl - true to clone acl 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
  - execProcedure
```
public void execProcedure(String signature,
                          String instance,
                          Map<String,String> props)
                   throws IOException
```
    Description copied from interface: Admin
    
    Execute a distributed procedure on a cluster.
    
    Specified by:
    
    execProcedure in interface Admin
    
    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 - if a remote or network exception occurs
  - execProcedureWithReturn
```
public byte[] execProcedureWithReturn(String signature,
                                      String instance,
                                      Map<String,String> props)
                               throws IOException
```
    Description copied from interface: Admin
    
    Execute a distributed procedure on a cluster.
    
    Specified by:
    
    execProcedureWithReturn in interface Admin
    
    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 - if a remote or network exception occurs
  - isProcedureFinished
```
public boolean isProcedureFinished(String signature,
                                   String instance,
                                   Map<String,String> props)
                            throws IOException
```
    Description copied from interface: Admin
    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
    Specified by:
    
    isProcedureFinished in interface Admin
    
    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
```
public List<SnapshotDescription> listSnapshots()
                                        throws IOException
```
    Description copied from interface: Admin
    
    List completed snapshots.
    
    Specified by:
    
    listSnapshots in interface Admin
    
    Returns:
    
    a list of snapshot descriptors for completed snapshots
    
    Throws:
    
    IOException - if a network error occurs
  - listSnapshots
```
public List<SnapshotDescription> listSnapshots(Pattern pattern)
                                        throws IOException
```
    Description copied from interface: Admin
    
    List all the completed snapshots matching the given pattern.
    
    Specified by:
    
    listSnapshots in interface Admin
    
    Parameters:
    
    pattern - The compiled regular expression to match against
    
    Returns:
    
    list of SnapshotDescription
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - listTableSnapshots
```
public List<SnapshotDescription> listTableSnapshots(Pattern tableNamePattern,
                                                    Pattern snapshotNamePattern)
                                             throws IOException
```
    Description copied from interface: Admin
    
    List all the completed snapshots matching the given table name regular expression and snapshot name regular expression.
    
    Specified by:
    
    listTableSnapshots in interface Admin
    
    Parameters:
    
    tableNamePattern - The compiled table name regular expression to match against
    
    snapshotNamePattern - The compiled snapshot name regular expression to match against
    
    Returns:
    
    list of completed SnapshotDescription
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - deleteSnapshot
```
public void deleteSnapshot(String snapshotName)
                    throws IOException
```
    Description copied from interface: Admin
    
    Delete an existing snapshot.
    
    Specified by:
    
    deleteSnapshot in interface Admin
    
    Parameters:
    
    snapshotName - name of the snapshot
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - deleteSnapshots
```
public void deleteSnapshots(Pattern pattern)
                     throws IOException
```
    Description copied from interface: Admin
    
    Delete existing snapshots whose names match the pattern passed.
    
    Specified by:
    
    deleteSnapshots in interface Admin
    
    Parameters:
    
    pattern - pattern for names of the snapshot to match
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - deleteTableSnapshots
```
public void deleteTableSnapshots(Pattern tableNamePattern,
                                 Pattern snapshotNamePattern)
                          throws IOException
```
    Description copied from interface: Admin
    
    Delete all existing snapshots matching the given table name regular expression and snapshot name regular expression.
    
    Specified by:
    
    deleteTableSnapshots in interface Admin
    
    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
```
public void setQuota(QuotaSettings quota)
              throws IOException
```
    Description copied from interface: Admin
    
    Apply the new quota settings.
    
    Specified by:
    
    setQuota in interface Admin
    
    Parameters:
    
    quota - the quota settings
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - getQuota
```
public List<QuotaSettings> getQuota(QuotaFilter filter)
                             throws IOException
```
    Description copied from interface: Admin
    
    List the quotas based on the filter.
    
    Specified by:
    
    getQuota in interface Admin
    
    Parameters:
    
    filter - the quota settings filter
    
    Returns:
    
    the QuotaSetting list
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - coprocessorService
```
public CoprocessorRpcChannel coprocessorService()
```
    Description copied from interface: Admin
    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);
    Specified by:
    
    coprocessorService in interface Admin
    
    Returns:
    
    A MasterCoprocessorRpcChannel instance
  - coprocessorService
```
public CoprocessorRpcChannel coprocessorService(ServerName serverName)
```
    Description copied from interface: Admin
    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);
    Specified by:
    
    coprocessorService in interface Admin
    
    Parameters:
    
    serverName - the server name to which the endpoint call is made
    
    Returns:
    
    A RegionServerCoprocessorRpcChannel instance
  - updateConfiguration
```
public void updateConfiguration(ServerName server)
                         throws IOException
```
    Description copied from interface: Admin
    
    Update the configuration and trigger an online config change on the regionserver.
    
    Specified by:
    
    updateConfiguration in interface Admin
    
    Parameters:
    
    server - : The server whose config needs to be updated.
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - updateConfiguration
```
public void updateConfiguration()
                         throws IOException
```
    Description copied from interface: Admin
    
    Update the configuration and trigger an online config change on all the regionservers.
    
    Specified by:
    
    updateConfiguration in interface Admin
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - getSecurityCapabilities
```
public List<SecurityCapability> getSecurityCapabilities()
                                                 throws IOException
```
    Description copied from interface: Admin
    
    Return the set of supported security capabilities.
    
    Specified by:
    
    getSecurityCapabilities in interface Admin
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - splitSwitch
```
public boolean splitSwitch(boolean enabled,
                           boolean synchronous)
                    throws IOException
```
    Description copied from interface: Admin
    
    Turn the split switch on or off.
    
    Specified by:
    
    splitSwitch in interface Admin
    
    Parameters:
    
    enabled - enabled or not
    
    synchronous - If true, it waits until current split() call, if outstanding, to return.
    
    Returns:
    
    Previous switch value
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - mergeSwitch
```
public boolean mergeSwitch(boolean enabled,
                           boolean synchronous)
                    throws IOException
```
    Description copied from interface: Admin
    
    Turn the merge switch on or off.
    
    Specified by:
    
    mergeSwitch in interface Admin
    
    Parameters:
    
    enabled - enabled or not
    
    synchronous - If true, it waits until current merge() call, if outstanding, to return.
    
    Returns:
    
    Previous switch value
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - isSplitEnabled
```
public boolean isSplitEnabled()
                       throws IOException
```
    Description copied from interface: Admin
    
    Query the current state of the split switch.
    
    Specified by:
    
    isSplitEnabled in interface Admin
    
    Returns:
    
    true if the switch is enabled, false otherwise.
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - isMergeEnabled
```
public boolean isMergeEnabled()
                       throws IOException
```
    Description copied from interface: Admin
    
    Query the current state of the merge switch.
    
    Specified by:
    
    isMergeEnabled in interface Admin
    
    Returns:
    
    true if the switch is enabled, false otherwise.
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - addReplicationPeerAsync
```
public Future<Void> addReplicationPeerAsync(String peerId,
                                            ReplicationPeerConfig peerConfig,
                                            boolean enabled)
                                     throws IOException
```
    Description copied from interface: Admin
    
    Add a new replication peer but does not block and wait for it.
    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.
    
    Specified by:
    
    addReplicationPeerAsync in interface Admin
    
    Parameters:
    
    peerId - a short name that identifies the peer
    
    peerConfig - configuration for the replication peer
    
    enabled - peer state, true if ENABLED and false if DISABLED
    
    Returns:
    
    the result of the async operation
    
    Throws:
    
    IOException - IOException if a remote or network exception occurs
  - removeReplicationPeerAsync
```
public Future<Void> removeReplicationPeerAsync(String peerId)
                                        throws IOException
```
    Description copied from interface: Admin
    
    Remove a replication peer but does not block and wait for it.
    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.
    
    Specified by:
    
    removeReplicationPeerAsync in interface Admin
    
    Parameters:
    
    peerId - a short name that identifies the peer
    
    Returns:
    
    the result of the async operation
    
    Throws:
    
    IOException - IOException if a remote or network exception occurs
  - enableReplicationPeerAsync
```
public Future<Void> enableReplicationPeerAsync(String peerId)
                                        throws IOException
```
    Description copied from interface: Admin
    
    Enable a replication peer but does not block and wait for it.
    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.
    
    Specified by:
    
    enableReplicationPeerAsync in interface Admin
    
    Parameters:
    
    peerId - a short name that identifies the peer
    
    Returns:
    
    the result of the async operation
    
    Throws:
    
    IOException - IOException if a remote or network exception occurs
  - disableReplicationPeerAsync
```
public Future<Void> disableReplicationPeerAsync(String peerId)
                                         throws IOException
```
    Description copied from interface: Admin
    
    Disable a replication peer but does not block and wait for it.
    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.
    
    Specified by:
    
    disableReplicationPeerAsync in interface Admin
    
    Parameters:
    
    peerId - a short name that identifies the peer
    
    Returns:
    
    the result of the async operation
    
    Throws:
    
    IOException - IOException if a remote or network exception occurs
  - getReplicationPeerConfig
```
public ReplicationPeerConfig getReplicationPeerConfig(String peerId)
                                               throws IOException
```
    Description copied from interface: Admin
    
    Returns the configured ReplicationPeerConfig for the specified peer.
    
    Specified by:
    
    getReplicationPeerConfig in interface Admin
    
    Parameters:
    
    peerId - a short name that identifies the peer
    
    Returns:
    
    ReplicationPeerConfig for the peer
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - updateReplicationPeerConfigAsync
```
public Future<Void> updateReplicationPeerConfigAsync(String peerId,
                                                     ReplicationPeerConfig peerConfig)
                                              throws IOException
```
    Description copied from interface: Admin
    
    Update the peerConfig for the specified peer but does not block and wait for it.
    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.
    
    Specified by:
    
    updateReplicationPeerConfigAsync in interface Admin
    
    Parameters:
    
    peerId - a short name that identifies the peer
    
    peerConfig - new config for the replication peer
    
    Returns:
    
    the result of the async operation
    
    Throws:
    
    IOException - IOException if a remote or network exception occurs
  - listReplicationPeers
```
public List<ReplicationPeerDescription> listReplicationPeers()
                                                      throws IOException
```
    Description copied from interface: Admin
    
    Return a list of replication peers.
    
    Specified by:
    
    listReplicationPeers in interface Admin
    
    Returns:
    
    a list of replication peers description
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - listReplicationPeers
```
public List<ReplicationPeerDescription> listReplicationPeers(Pattern pattern)
                                                      throws IOException
```
    Description copied from interface: Admin
    
    Return a list of replication peers.
    
    Specified by:
    
    listReplicationPeers in interface Admin
    
    Parameters:
    
    pattern - The compiled regular expression to match peer id
    
    Returns:
    
    a list of replication peers description
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - transitReplicationPeerSyncReplicationStateAsync
```
public Future<Void> transitReplicationPeerSyncReplicationStateAsync(String peerId,
                                                                    SyncReplicationState state)
                                                             throws IOException
```
    Description copied from interface: Admin
    
    Transit current cluster to a new state in a synchronous replication peer. But does not block and wait for it.
    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.
    
    Specified by:
    
    transitReplicationPeerSyncReplicationStateAsync in interface Admin
    
    Parameters:
    
    peerId - a short name that identifies the peer
    
    state - a new state of current cluster
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - decommissionRegionServers
```
public void decommissionRegionServers(List<ServerName> servers,
                                      boolean offload)
                               throws IOException
```
    Description copied from interface: Admin
    
    Mark region server(s) as decommissioned to prevent additional regions from getting assigned to them. Optionally unload the regions on the servers. If there are multiple servers to be decommissioned, decommissioning them at the same time can prevent wasteful region movements. Region unloading is asynchronous.
    
    Specified by:
    
    decommissionRegionServers in interface Admin
    
    Parameters:
    
    servers - The list of servers to decommission.
    
    offload - True to offload the regions from the decommissioned servers
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - listDecommissionedRegionServers
```
public List<ServerName> listDecommissionedRegionServers()
                                                 throws IOException
```
    Description copied from interface: Admin
    
    List region servers marked as decommissioned, which can not be assigned regions.
    
    Specified by:
    
    listDecommissionedRegionServers in interface Admin
    
    Returns:
    
    List of decommissioned region servers.
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - recommissionRegionServer
```
public void recommissionRegionServer(ServerName server,
                                     List<byte[]> encodedRegionNames)
                              throws IOException
```
    Description copied from interface: Admin
    
    Remove decommission marker from a region server to allow regions assignments. Load regions onto the server if a list of regions is given. Region loading is asynchronous.
    
    Specified by:
    
    recommissionRegionServer in interface Admin
    
    Parameters:
    
    server - The server to recommission.
    
    encodedRegionNames - Regions to load onto the server.
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - listReplicatedTableCFs
```
public List<TableCFs> listReplicatedTableCFs()
                                      throws IOException
```
    Description copied from interface: Admin
    
    Find all table and column families that are replicated from this cluster
    
    Specified by:
    
    listReplicatedTableCFs in interface Admin
    
    Returns:
    
    the replicated table-cfs list of this cluster.
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - enableTableReplication
```
public void enableTableReplication(TableName tableName)
                            throws IOException
```
    Description copied from interface: Admin
    
    Enable a table's replication switch.
    
    Specified by:
    
    enableTableReplication in interface Admin
    
    Parameters:
    
    tableName - name of the table
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - disableTableReplication
```
public void disableTableReplication(TableName tableName)
                             throws IOException
```
    Description copied from interface: Admin
    
    Disable a table's replication switch.
    
    Specified by:
    
    disableTableReplication in interface Admin
    
    Parameters:
    
    tableName - name of the table
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - clearCompactionQueues
```
public void clearCompactionQueues(ServerName serverName,
                                  Set<String> queues)
                           throws IOException,
                                  InterruptedException
```
    Description copied from interface: Admin
    
    Clear compacting queues on a regionserver.
    
    Specified by:
    
    clearCompactionQueues in interface Admin
    
    Parameters:
    
    serverName - the region server name
    
    queues - the set of queue name
    
    Throws:
    
    IOException - if a remote or network exception occurs
    
    InterruptedException
  - clearDeadServers
```
public List<ServerName> clearDeadServers(List<ServerName> servers)
                                  throws IOException
```
    Description copied from interface: Admin
    
    Clear dead region servers from master.
    
    Specified by:
    
    clearDeadServers in interface Admin
    
    Parameters:
    
    servers - list of dead region servers.
    
    Returns:
    
    List of servers that are not cleared
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - cloneTableSchema
```
public void cloneTableSchema(TableName tableName,
                             TableName newTableName,
                             boolean preserveSplits)
                      throws IOException
```
    Description copied from interface: Admin
    
    Create a new table by cloning the existent table schema.
    
    Specified by:
    
    cloneTableSchema in interface Admin
    
    Parameters:
    
    tableName - name of the table to be cloned
    
    newTableName - name of the new table where the table will be created
    
    preserveSplits - True if the splits should be preserved
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - switchRpcThrottle
```
public boolean switchRpcThrottle(boolean enable)
                          throws IOException
```
    Description copied from interface: Admin
    
    Switch the rpc throttle enable state.
    
    Specified by:
    
    switchRpcThrottle in interface Admin
    
    Parameters:
    
    enable - Set to true to enable, false to disable.
    
    Returns:
    
    Previous rpc throttle enabled value
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - isRpcThrottleEnabled
```
public boolean isRpcThrottleEnabled()
                             throws IOException
```
    Description copied from interface: Admin
    
    Get if the rpc throttle is enabled.
    
    Specified by:
    
    isRpcThrottleEnabled in interface Admin
    
    Returns:
    
    True if rpc throttle is enabled
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - exceedThrottleQuotaSwitch
```
public boolean exceedThrottleQuotaSwitch(boolean enable)
                                  throws IOException
```
    Description copied from interface: Admin
    
    Switch the exceed throttle quota. If enabled, user/table/namespace throttle quota can be exceeded if region server has availble quota.
    
    Specified by:
    
    exceedThrottleQuotaSwitch in interface Admin
    
    Parameters:
    
    enable - Set to true to enable, false to disable.
    
    Returns:
    
    Previous exceed throttle enabled value
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - getSpaceQuotaTableSizes
```
public Map<TableName,Long> getSpaceQuotaTableSizes()
                                            throws IOException
```
    Description copied from interface: Admin
    
    Fetches the table sizes on the filesystem as tracked by the HBase Master.
    
    Specified by:
    
    getSpaceQuotaTableSizes in interface Admin
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - getRegionServerSpaceQuotaSnapshots
```
public Map<TableName,? extends SpaceQuotaSnapshotView> getRegionServerSpaceQuotaSnapshots(ServerName serverName)
                                                                                   throws IOException
```
    Description copied from interface: Admin
    
    Fetches the observed SpaceQuotaSnapshotViews observed by a RegionServer.
    
    Specified by:
    
    getRegionServerSpaceQuotaSnapshots in interface Admin
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - getCurrentSpaceQuotaSnapshot
```
public SpaceQuotaSnapshotView getCurrentSpaceQuotaSnapshot(String namespace)
                                                    throws IOException
```
    Description copied from interface: Admin
    
    Returns the Master's view of a quota on the given namespace or null if the Master has no quota information on that namespace.
    
    Specified by:
    
    getCurrentSpaceQuotaSnapshot in interface Admin
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - getCurrentSpaceQuotaSnapshot
```
public SpaceQuotaSnapshotView getCurrentSpaceQuotaSnapshot(TableName tableName)
                                                    throws IOException
```
    Description copied from interface: Admin
    
    Returns the Master's view of a quota on the given tableName or null if the Master has no quota information on that table.
    
    Specified by:
    
    getCurrentSpaceQuotaSnapshot in interface Admin
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - grant
```
public void grant(UserPermission userPermission,
                  boolean mergeExistingPermissions)
           throws IOException
```
    Description copied from interface: Admin
    
    Grants user specific permissions
    
    Specified by:
    
    grant in interface Admin
    
    Parameters:
    
    userPermission - user name and the specific permission
    
    mergeExistingPermissions - If set to false, later granted permissions will override previous granted permissions. otherwise, it'll merge with previous granted permissions.
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - revoke
```
public void revoke(UserPermission userPermission)
            throws IOException
```
    Description copied from interface: Admin
    
    Revokes user specific permissions
    
    Specified by:
    
    revoke in interface Admin
    
    Parameters:
    
    userPermission - user name and the specific permission
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - getUserPermissions
```
public List<UserPermission> getUserPermissions(GetUserPermissionsRequest getUserPermissionsRequest)
                                        throws IOException
```
    Description copied from interface: Admin
    
    Get the global/namespace/table permissions for user
    
    Specified by:
    
    getUserPermissions in interface Admin
    
    Parameters:
    
    getUserPermissionsRequest - A request contains which user, global, namespace or table permissions needed
    
    Returns:
    
    The user and permission list
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - hasUserPermissions
```
public List<Boolean> hasUserPermissions(String userName,
                                        List<Permission> permissions)
                                 throws IOException
```
    Description copied from interface: Admin
    
    Check if the user has specific permissions
    
    Specified by:
    
    hasUserPermissions in interface Admin
    
    Parameters:
    
    userName - the user name
    
    permissions - the specific permission list
    
    Returns:
    
    True if user has the specific permissions
    
    Throws:
    
    IOException - if a remote or network exception occurs

Class AdminOverAsyncAdmin

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface org.apache.hadoop.hbase.client.Admin

Field Detail

LOG

aborted

conn

admin

operationTimeout

syncWaitTimeout

Constructor Detail

AdminOverAsyncAdmin

Method Detail

getOperationTimeout

getSyncWaitTimeout

abort

isAborted

getConnection

tableExists

listTableDescriptors

listTableDescriptors

listTableNames

listTableNames

getDescriptor

createTable

createTableAsync

createTableAsync

deleteTableAsync

truncateTableAsync

enableTableAsync

disableTableAsync

isTableEnabled

isTableDisabled

isTableAvailable

addColumnFamilyAsync

deleteColumnFamilyAsync

modifyColumnFamilyAsync

getRegions

flush

flushRegion

flushRegionServer

compact

compactRegion

compact

compactRegion

compact

compact

majorCompact

majorCompactRegion

majorCompact

majorCompactRegion

majorCompact

majorCompact

compactionSwitch

compactRegionServer

majorCompactRegionServer

move

move

assign

unassign

offline

balancerSwitch

balance

balance

isBalancerEnabled

clearBlockCache

normalize

isNormalizerEnabled

normalizerSwitch

catalogJanitorSwitch

runCatalogJanitor

isCatalogJanitorEnabled

cleanerChoreSwitch

runCleanerChore

isCleanerChoreEnabled

mergeRegionsAsync