AsyncAdmin (Apache HBase 2.2.3 API)

All Known Implementing Classes:

AsyncHBaseAdmin, RawAsyncHBaseAdmin
```
@InterfaceAudience.Public
public interface AsyncAdmin
```
The asynchronous administrative API for HBase.

Since:

2.0.0

Method Summary

All Methods Instance Methods Abstract Methods Default Methods Deprecated Methods
Modifier and Type	Method and Description
`CompletableFuture<Boolean>`	`abortProcedure(long procId, boolean mayInterruptIfRunning)` Deprecated. since 2.1.1 and will be removed in 4.0.0.
`CompletableFuture<Void>`	`addColumnFamily(TableName tableName, ColumnFamilyDescriptor columnFamily)` Add a column family to an existing table.
`default CompletableFuture<Void>`	`addReplicationPeer(String peerId, ReplicationPeerConfig peerConfig)` Add a new replication peer for replicating data to slave cluster
`CompletableFuture<Void>`	`addReplicationPeer(String peerId, ReplicationPeerConfig peerConfig, boolean enabled)` Add a new replication peer for replicating data to slave cluster
`CompletableFuture<Void>`	`appendReplicationPeerTableCFs(String peerId, Map<TableName,List<String>> tableCfs)` Append the replicable table-cf config of the specified peer
`CompletableFuture<Void>`	`assign(byte[] regionName)`
`default CompletableFuture<Boolean>`	`balance()` Invoke the balancer.
`CompletableFuture<Boolean>`	`balance(boolean forcible)` Invoke the balancer.
`default CompletableFuture<Boolean>`	`balancerSwitch(boolean on)` Turn the load balancer on or off.
`CompletableFuture<Boolean>`	`balancerSwitch(boolean on, boolean drainRITs)` Turn the load balancer on or off.
`CompletableFuture<Boolean>`	`catalogJanitorSwitch(boolean on)` Turn the catalog janitor on/off.
`CompletableFuture<Boolean>`	`cleanerChoreSwitch(boolean on)` Turn the cleaner chore on/off.
`CompletableFuture<CacheEvictionStats>`	`clearBlockCache(TableName tableName)` Clear all the blocks corresponding to this table from BlockCache.
`CompletableFuture<Void>`	`clearCompactionQueues(ServerName serverName, Set<String> queues)` Clear compacting queues on a region server.
`CompletableFuture<List<ServerName>>`	`clearDeadServers(List<ServerName> servers)` Clear dead region servers from master.
`default CompletableFuture<Void>`	`cloneSnapshot(String snapshotName, TableName tableName)` Create a new table by cloning the snapshot content.
`CompletableFuture<Void>`	`cloneSnapshot(String snapshotName, TableName tableName, boolean restoreAcl)` Create a new table by cloning the snapshot content.
`CompletableFuture<Void>`	`cloneTableSchema(TableName tableName, TableName newTableName, boolean preserveSplits)` Create a new table by cloning the existent table schema.
`default CompletableFuture<Void>`	`compact(TableName tableName)` Compact a table.
`default CompletableFuture<Void>`	`compact(TableName tableName, byte[] columnFamily)` Compact a column family within a table.
`CompletableFuture<Void>`	`compact(TableName tableName, byte[] columnFamily, CompactType compactType)` Compact a column family within a table.
`CompletableFuture<Void>`	`compact(TableName tableName, CompactType compactType)` Compact a table.
`CompletableFuture<Map<ServerName,Boolean>>`	`compactionSwitch(boolean switchState, List<String> serverNamesList)` Turn the compaction on or off.
`CompletableFuture<Void>`	`compactRegion(byte[] regionName)` Compact an individual region.
`CompletableFuture<Void>`	`compactRegion(byte[] regionName, byte[] columnFamily)` Compact a column family within a region.
`CompletableFuture<Void>`	`compactRegionServer(ServerName serverName)` Compact all regions on the region server.
`<S,R> CompletableFuture<R>`	`coprocessorService(Function<com.google.protobuf.RpcChannel,S> stubMaker, ServiceCaller<S,R> callable)` Execute the given coprocessor call on the master.
`<S,R> CompletableFuture<R>`	`coprocessorService(Function<com.google.protobuf.RpcChannel,S> stubMaker, ServiceCaller<S,R> callable, ServerName serverName)` Execute the given coprocessor call on the given region server.
`CompletableFuture<Void>`	`createNamespace(NamespaceDescriptor descriptor)` Create a new namespace.
`CompletableFuture<Void>`	`createTable(TableDescriptor desc)` Creates a new table.
`CompletableFuture<Void>`	`createTable(TableDescriptor desc, byte[][] splitKeys)` Creates a new table with an initial set of empty regions defined by the specified split keys.
`CompletableFuture<Void>`	`createTable(TableDescriptor desc, byte[] startKey, byte[] endKey, int numRegions)` Creates a new table with the specified number of regions.
`CompletableFuture<Void>`	`decommissionRegionServers(List<ServerName> servers, boolean offload)` Mark region server(s) as decommissioned to prevent additional regions from getting assigned to them.
`CompletableFuture<Void>`	`deleteColumnFamily(TableName tableName, byte[] columnFamily)` Delete a column family from a table.
`CompletableFuture<Void>`	`deleteNamespace(String name)` Delete an existing namespace.
`CompletableFuture<Void>`	`deleteSnapshot(String snapshotName)` Delete an existing snapshot.
`CompletableFuture<Void>`	`deleteSnapshots()` Delete all existing snapshots.
`CompletableFuture<Void>`	`deleteSnapshots(Pattern pattern)` Delete existing snapshots whose names match the pattern passed.
`CompletableFuture<Void>`	`deleteTable(TableName tableName)` Deletes a table.
`CompletableFuture<Void>`	`deleteTableSnapshots(Pattern tableNamePattern)` Delete all existing snapshots matching the given table name pattern.
`CompletableFuture<Void>`	`deleteTableSnapshots(Pattern tableNamePattern, Pattern snapshotNamePattern)` Delete all existing snapshots matching the given table name regular expression and snapshot name regular expression.
`CompletableFuture<Void>`	`disableReplicationPeer(String peerId)` Stop the replication stream to the specified peer
`CompletableFuture<Void>`	`disableTable(TableName tableName)` Disable a table.
`CompletableFuture<Void>`	`disableTableReplication(TableName tableName)` Disable a table's replication switch.
`CompletableFuture<Void>`	`enableReplicationPeer(String peerId)` Restart the replication stream to the specified peer
`CompletableFuture<Void>`	`enableTable(TableName tableName)` Enable a table.
`CompletableFuture<Void>`	`enableTableReplication(TableName tableName)` Enable a table's replication switch.
`CompletableFuture<Boolean>`	`exceedThrottleQuotaSwitch(boolean enable)` Switch the exceed throttle quota.
`CompletableFuture<Void>`	`execProcedure(String signature, String instance, Map<String,String> props)` Execute a distributed procedure on a cluster.
`CompletableFuture<byte[]>`	`execProcedureWithReturn(String signature, String instance, Map<String,String> props)` Execute a distributed procedure on a cluster.
`CompletableFuture<Void>`	`flush(TableName tableName)` Flush a table.
`CompletableFuture<Void>`	`flushRegion(byte[] regionName)` Flush an individual region.
`CompletableFuture<Void>`	`flushRegionServer(ServerName serverName)` Flush all region on the region server.
`default CompletableFuture<Collection<ServerName>>`	`getBackupMasters()`
`CompletableFuture<ClusterMetrics>`	`getClusterMetrics()`
`CompletableFuture<ClusterMetrics>`	`getClusterMetrics(EnumSet<ClusterMetrics.Option> options)`
`default CompletableFuture<CompactionState>`	`getCompactionState(TableName tableName)` Get the current compaction state of a table.
`CompletableFuture<CompactionState>`	`getCompactionState(TableName tableName, CompactType compactType)` Get the current compaction state of a table.
`CompletableFuture<CompactionState>`	`getCompactionStateForRegion(byte[] regionName)` Get the current compaction state of region.
`CompletableFuture<? extends 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.
`CompletableFuture<? extends 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.
`CompletableFuture<TableDescriptor>`	`getDescriptor(TableName tableName)` Method for getting the tableDescriptor
`CompletableFuture<Optional<Long>>`	`getLastMajorCompactionTimestamp(TableName tableName)` Get the timestamp of the last major compaction for the passed table.
`CompletableFuture<Optional<Long>>`	`getLastMajorCompactionTimestampForRegion(byte[] regionName)` Get the timestamp of the last major compaction for the passed region.
`CompletableFuture<String>`	`getLocks()` List locks.
`default CompletableFuture<ServerName>`	`getMaster()`
`default CompletableFuture<List<String>>`	`getMasterCoprocessorNames()`
`default CompletableFuture<Integer>`	`getMasterInfoPort()` Get the info port of the current master if one is available.
`CompletableFuture<NamespaceDescriptor>`	`getNamespaceDescriptor(String name)` Get a namespace descriptor by name
`CompletableFuture<String>`	`getProcedures()` List procedures
`CompletableFuture<List<QuotaSettings>>`	`getQuota(QuotaFilter filter)` List the quotas based on the filter.
`CompletableFuture<List<RegionMetrics>>`	`getRegionMetrics(ServerName serverName)` Get a list of `RegionMetrics` of all regions hosted on a region seerver.
`CompletableFuture<List<RegionMetrics>>`	`getRegionMetrics(ServerName serverName, TableName tableName)` Get a list of `RegionMetrics` of all regions hosted on a region seerver for a table.
`CompletableFuture<List<RegionInfo>>`	`getRegions(ServerName serverName)` Get all the online regions on a region server.
`CompletableFuture<List<RegionInfo>>`	`getRegions(TableName tableName)` Get the regions of a given table.
`default CompletableFuture<Collection<ServerName>>`	`getRegionServers()`
`CompletableFuture<? extends Map<TableName,? extends SpaceQuotaSnapshotView>>`	`getRegionServerSpaceQuotaSnapshots(ServerName serverName)` Fetches the observed `SpaceQuotaSnapshotView`s observed by a RegionServer.
`CompletableFuture<ReplicationPeerConfig>`	`getReplicationPeerConfig(String peerId)` Returns the configured ReplicationPeerConfig for the specified peer
`CompletableFuture<List<SecurityCapability>>`	`getSecurityCapabilities()`
`CompletableFuture<Map<TableName,Long>>`	`getSpaceQuotaTableSizes()` Fetches the table sizes on the filesystem as tracked by the HBase Master.
`CompletableFuture<List<UserPermission>>`	`getUserPermissions(GetUserPermissionsRequest getUserPermissionsRequest)` Get the global/namespace/table permissions for user
`CompletableFuture<Void>`	`grant(UserPermission userPermission, boolean mergeExistingPermissions)` Grants user specific permissions
`default CompletableFuture<List<Boolean>>`	`hasUserPermissions(List<Permission> permissions)` Check if call user has specific permissions
`CompletableFuture<List<Boolean>>`	`hasUserPermissions(String userName, List<Permission> permissions)` Check if the user has specific permissions
`CompletableFuture<Boolean>`	`isBalancerEnabled()` Query the current state of the balancer.
`CompletableFuture<Boolean>`	`isCatalogJanitorEnabled()` Query on the catalog janitor state.
`CompletableFuture<Boolean>`	`isCleanerChoreEnabled()` Query the current state of the cleaner chore.
`CompletableFuture<Boolean>`	`isMasterInMaintenanceMode()` Check whether master is in maintenance mode
`CompletableFuture<Boolean>`	`isMergeEnabled()` Query the current state of the Merge switch.
`CompletableFuture<Boolean>`	`isNormalizerEnabled()` Query the current state of the region normalizer
`CompletableFuture<Boolean>`	`isProcedureFinished(String signature, String instance, Map<String,String> props)` Check the current state of the specified procedure.
`CompletableFuture<Boolean>`	`isRpcThrottleEnabled()` Get if the rpc throttle is enabled.
`CompletableFuture<Boolean>`	`isSnapshotFinished(SnapshotDescription snapshot)` Check the current state of the passed snapshot.
`CompletableFuture<Boolean>`	`isSplitEnabled()` Query the current state of the Split switch.
`CompletableFuture<Boolean>`	`isTableAvailable(TableName tableName)`
`CompletableFuture<Boolean>`	`isTableAvailable(TableName tableName, byte[][] splitKeys)` Deprecated. Since 2.2.0. Will be removed in 3.0.0. Use `isTableAvailable(TableName)`
`CompletableFuture<Boolean>`	`isTableDisabled(TableName tableName)`
`CompletableFuture<Boolean>`	`isTableEnabled(TableName tableName)`
`default CompletableFuture<List<ServerName>>`	`listDeadServers()` List all the dead region servers.
`CompletableFuture<List<ServerName>>`	`listDecommissionedRegionServers()` List region servers marked as decommissioned, which can not be assigned regions.
`CompletableFuture<List<NamespaceDescriptor>>`	`listNamespaceDescriptors()` List available namespace descriptors
`CompletableFuture<List<TableCFs>>`	`listReplicatedTableCFs()` Find all table and column families that are replicated from this cluster
`CompletableFuture<List<ReplicationPeerDescription>>`	`listReplicationPeers()` Return a list of replication peers.
`CompletableFuture<List<ReplicationPeerDescription>>`	`listReplicationPeers(Pattern pattern)` Return a list of replication peers.
`CompletableFuture<List<SnapshotDescription>>`	`listSnapshots()` List completed snapshots.
`CompletableFuture<List<SnapshotDescription>>`	`listSnapshots(Pattern pattern)` List all the completed snapshots matching the given pattern.
`default CompletableFuture<List<TableDescriptor>>`	`listTableDescriptors()` List all the userspace tables.
`CompletableFuture<List<TableDescriptor>>`	`listTableDescriptors(boolean includeSysTables)` List all the tables.
`CompletableFuture<List<TableDescriptor>>`	`listTableDescriptors(List<TableName> tableNames)` List specific tables including system tables.
`CompletableFuture<List<TableDescriptor>>`	`listTableDescriptors(Pattern pattern, boolean includeSysTables)` List all the tables matching the given pattern.
`CompletableFuture<List<TableDescriptor>>`	`listTableDescriptorsByNamespace(String name)` Get list of table descriptors by namespace.
`default CompletableFuture<List<TableName>>`	`listTableNames()` List all of the names of userspace tables.
`CompletableFuture<List<TableName>>`	`listTableNames(boolean includeSysTables)` List all of the names of tables.
`CompletableFuture<List<TableName>>`	`listTableNames(Pattern pattern, boolean includeSysTables)` List all of the names of userspace tables.
`CompletableFuture<List<TableName>>`	`listTableNamesByNamespace(String name)` Get list of table names by namespace.
`CompletableFuture<List<SnapshotDescription>>`	`listTableSnapshots(Pattern tableNamePattern)` List all the completed snapshots matching the given table name pattern.
`CompletableFuture<List<SnapshotDescription>>`	`listTableSnapshots(Pattern tableNamePattern, Pattern snapshotNamePattern)` List all the completed snapshots matching the given table name regular expression and snapshot name regular expression.
`default CompletableFuture<Void>`	`majorCompact(TableName tableName)` Major compact a table.
`default CompletableFuture<Void>`	`majorCompact(TableName tableName, byte[] columnFamily)` Major compact a column family within a table.
`CompletableFuture<Void>`	`majorCompact(TableName tableName, byte[] columnFamily, CompactType compactType)` Major compact a column family within a table.
`CompletableFuture<Void>`	`majorCompact(TableName tableName, CompactType compactType)` Major compact a table.
`CompletableFuture<Void>`	`majorCompactRegion(byte[] regionName)` Major compact a region.
`CompletableFuture<Void>`	`majorCompactRegion(byte[] regionName, byte[] columnFamily)` Major compact a column family within region.
`CompletableFuture<Void>`	`majorCompactRegionServer(ServerName serverName)` Compact all regions on the region server.
`default CompletableFuture<Void>`	`mergeRegions(byte[] nameOfRegionA, byte[] nameOfRegionB, boolean forcible)` Merge two regions.
`CompletableFuture<Void>`	`mergeRegions(List<byte[]> nameOfRegionsToMerge, boolean forcible)` Merge regions.
`default CompletableFuture<Boolean>`	`mergeSwitch(boolean enabled)` Turn the Merge switch on or off.
`CompletableFuture<Boolean>`	`mergeSwitch(boolean enabled, boolean drainMerges)` Turn the Merge switch on or off.
`CompletableFuture<Void>`	`modifyColumnFamily(TableName tableName, ColumnFamilyDescriptor columnFamily)` Modify an existing column family on a table.
`CompletableFuture<Void>`	`modifyNamespace(NamespaceDescriptor descriptor)` Modify an existing namespace.
`CompletableFuture<Void>`	`modifyTable(TableDescriptor desc)` Modify an existing table, more IRB friendly version.
`CompletableFuture<Void>`	`move(byte[] regionName)` Move the region `r` to a random server.
`CompletableFuture<Void>`	`move(byte[] regionName, ServerName destServerName)` Move the region `r` to `dest`.
`CompletableFuture<Boolean>`	`normalize()` Invoke region normalizer.
`CompletableFuture<Boolean>`	`normalizerSwitch(boolean on)` Set region normalizer on/off.
`CompletableFuture<Void>`	`offline(byte[] regionName)` Offline specified region from master's in-memory state.
`CompletableFuture<Void>`	`recommissionRegionServer(ServerName server, List<byte[]> encodedRegionNames)` Remove decommission marker from a region server to allow regions assignments.
`CompletableFuture<Void>`	`removeReplicationPeer(String peerId)` Remove a peer and stop the replication
`CompletableFuture<Void>`	`removeReplicationPeerTableCFs(String peerId, Map<TableName,List<String>> tableCfs)` Remove some table-cfs from config of the specified peer
`CompletableFuture<Void>`	`restoreSnapshot(String snapshotName)` Restore the specified snapshot on the original table.
`default CompletableFuture<Void>`	`restoreSnapshot(String snapshotName, boolean takeFailSafeSnapshot)` Restore the specified snapshot on the original table.
`CompletableFuture<Void>`	`restoreSnapshot(String snapshotName, boolean takeFailSafeSnapshot, boolean restoreAcl)` Restore the specified snapshot on the original table.
`CompletableFuture<Void>`	`revoke(UserPermission userPermission)` Revokes user specific permissions
`CompletableFuture<Void>`	`rollWALWriter(ServerName serverName)` Roll the log writer.
`CompletableFuture<Integer>`	`runCatalogJanitor()` Ask for a scan of the catalog table.
`CompletableFuture<Boolean>`	`runCleanerChore()` Ask for cleaner chore to run.
`CompletableFuture<Void>`	`setQuota(QuotaSettings quota)` Apply the new quota settings.
`CompletableFuture<Void>`	`shutdown()` Shuts down the HBase cluster.
`CompletableFuture<Void>`	`snapshot(SnapshotDescription snapshot)` Take a snapshot and wait for the server to complete that snapshot asynchronously.
`default CompletableFuture<Void>`	`snapshot(String snapshotName, TableName tableName)` Take a snapshot for the given table.
`default CompletableFuture<Void>`	`snapshot(String snapshotName, TableName tableName, SnapshotType type)` Create typed snapshot of the table.
`CompletableFuture<Void>`	`split(TableName tableName)` Split a table.
`CompletableFuture<Void>`	`split(TableName tableName, byte[] splitPoint)` Split a table.
`CompletableFuture<Void>`	`splitRegion(byte[] regionName)` Split an individual region.
`CompletableFuture<Void>`	`splitRegion(byte[] regionName, byte[] splitPoint)` Split an individual region.
`default CompletableFuture<Boolean>`	`splitSwitch(boolean enabled)` Turn the Split switch on or off.
`CompletableFuture<Boolean>`	`splitSwitch(boolean enabled, boolean drainSplits)` Turn the Split switch on or off.
`CompletableFuture<Void>`	`stopMaster()` Shuts down the current HBase master only.
`CompletableFuture<Void>`	`stopRegionServer(ServerName serverName)` Stop the designated regionserver.
`CompletableFuture<Boolean>`	`switchRpcThrottle(boolean enable)` Switch the rpc throttle enabled state.
`CompletableFuture<Boolean>`	`tableExists(TableName tableName)`
`CompletableFuture<Void>`	`truncateTable(TableName tableName, boolean preserveSplits)` Truncate a table.
`CompletableFuture<Void>`	`unassign(byte[] regionName, boolean forcible)` Unassign a region from current hosting regionserver.
`CompletableFuture<Void>`	`updateConfiguration()` Update the configuration and trigger an online config change on all the masters and regionservers.
`CompletableFuture<Void>`	`updateConfiguration(ServerName serverName)` Update the configuration and trigger an online config change on the regionserver.
`CompletableFuture<Void>`	`updateReplicationPeerConfig(String peerId, ReplicationPeerConfig peerConfig)` Update the peerConfig for the specified peer

- Method Detail
  - tableExists
```
CompletableFuture<Boolean> tableExists(TableName tableName)
```
    Parameters:
    
    tableName - Table to check.
    
    Returns:
    
    True if table exists already. The return value will be wrapped by a CompletableFuture.
  - listTableDescriptors
```
default CompletableFuture<List<TableDescriptor>> listTableDescriptors()
```
    List all the userspace tables.
    
    Returns:
    
    - returns a list of TableDescriptors wrapped by a CompletableFuture.
  - listTableDescriptors
```
CompletableFuture<List<TableDescriptor>> listTableDescriptors(boolean includeSysTables)
```
    List all the tables.
    
    Parameters:
    
    includeSysTables - False to match only against userspace tables
    
    Returns:
    
    - returns a list of TableDescriptors wrapped by a CompletableFuture.
  - listTableDescriptors
```
CompletableFuture<List<TableDescriptor>> listTableDescriptors(Pattern pattern,
                                                              boolean includeSysTables)
```
    List all the tables matching the given pattern.
    
    Parameters:
    
    pattern - The compiled regular expression to match against
    
    includeSysTables - False to match only against userspace tables
    
    Returns:
    
    - returns a list of TableDescriptors wrapped by a CompletableFuture.
  - listTableDescriptors
```
CompletableFuture<List<TableDescriptor>> listTableDescriptors(List<TableName> tableNames)
```
    List specific tables including system tables.
    
    Parameters:
    
    tableNames - the table list to match against
    
    Returns:
    
    - returns a list of TableDescriptors wrapped by a CompletableFuture.
  - listTableDescriptorsByNamespace
```
CompletableFuture<List<TableDescriptor>> listTableDescriptorsByNamespace(String name)
```
    Get list of table descriptors by namespace.
    
    Parameters:
    
    name - namespace name
    
    Returns:
    
    returns a list of TableDescriptors wrapped by a CompletableFuture.
  - listTableNames
```
default CompletableFuture<List<TableName>> listTableNames()
```
    List all of the names of userspace tables.
    
    Returns:
    
    a list of table names wrapped by a CompletableFuture.
    
    See Also:
    
    listTableNames(Pattern, boolean)
  - listTableNames
```
CompletableFuture<List<TableName>> listTableNames(boolean includeSysTables)
```
    List all of the names of tables.
    
    Parameters:
    
    includeSysTables - False to match only against userspace tables
    
    Returns:
    
    a list of table names wrapped by a CompletableFuture.
  - listTableNames
```
CompletableFuture<List<TableName>> listTableNames(Pattern pattern,
                                                  boolean includeSysTables)
```
    List all of the names of userspace tables.
    
    Parameters:
    
    pattern - The regular expression to match against
    
    includeSysTables - False to match only against userspace tables
    
    Returns:
    
    a list of table names wrapped by a CompletableFuture.
  - listTableNamesByNamespace
```
CompletableFuture<List<TableName>> listTableNamesByNamespace(String name)
```
    Get list of table names by namespace.
    
    Parameters:
    
    name - namespace name
    
    Returns:
    
    The list of table names in the namespace wrapped by a CompletableFuture.
  - getDescriptor
```
CompletableFuture<TableDescriptor> getDescriptor(TableName tableName)
```
    Method for getting the tableDescriptor
    
    Parameters:
    
    tableName - as a TableName
    
    Returns:
    
    the read-only tableDescriptor wrapped by a CompletableFuture.
  - createTable
```
CompletableFuture<Void> createTable(TableDescriptor desc)
```
    Creates a new table.
    
    Parameters:
    
    desc - table descriptor for table
  - createTable
```
CompletableFuture<Void> createTable(TableDescriptor desc,
                                    byte[] startKey,
                                    byte[] endKey,
                                    int numRegions)
```
    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.
    
    Parameters:
    
    desc - table descriptor for table
    
    startKey - beginning of key range
    
    endKey - end of key range
    
    numRegions - the total number of regions to create
  - createTable
```
CompletableFuture<Void> createTable(TableDescriptor desc,
                                    byte[][] splitKeys)
```
    Creates a new table with an initial set of empty regions defined by the specified split keys. The total number of regions created will be the number of split keys plus one. Note : Avoid passing empty split key.
    
    Parameters:
    
    desc - table descriptor for table
    
    splitKeys - array of split keys for the initial regions of the table
  - modifyTable
```
CompletableFuture<Void> modifyTable(TableDescriptor desc)
```
    Modify an existing table, more IRB friendly version.
    
    Parameters:
    
    desc - modified description of the table
  - deleteTable
```
CompletableFuture<Void> deleteTable(TableName tableName)
```
    Deletes a table.
    
    Parameters:
    
    tableName - name of table to delete
  - truncateTable
```
CompletableFuture<Void> truncateTable(TableName tableName,
                                      boolean preserveSplits)
```
    Truncate a table.
    
    Parameters:
    
    tableName - name of table to truncate
    
    preserveSplits - True if the splits should be preserved
  - enableTable
```
CompletableFuture<Void> enableTable(TableName tableName)
```
    Enable a table. The table has to be in disabled state for it to be enabled.
    
    Parameters:
    
    tableName - name of the table
  - disableTable
```
CompletableFuture<Void> disableTable(TableName tableName)
```
    Disable a table. The table has to be in enabled state for it to be disabled.
    
    Parameters:
    
    tableName -
  - isTableEnabled
```
CompletableFuture<Boolean> isTableEnabled(TableName tableName)
```
    Parameters:
    
    tableName - name of table to check
    
    Returns:
    
    true if table is on-line. The return value will be wrapped by a CompletableFuture.
  - isTableDisabled
```
CompletableFuture<Boolean> isTableDisabled(TableName tableName)
```
    Parameters:
    
    tableName - name of table to check
    
    Returns:
    
    true if table is off-line. The return value will be wrapped by a CompletableFuture.
  - isTableAvailable
```
CompletableFuture<Boolean> isTableAvailable(TableName tableName)
```
    Parameters:
    
    tableName - name of table to check
    
    Returns:
    
    true if all regions of the table are available. The return value will be wrapped by a CompletableFuture.
  - isTableAvailable
```
@Deprecated
CompletableFuture<Boolean> isTableAvailable(TableName tableName,
                                                        byte[][] splitKeys)
```
    Deprecated. Since 2.2.0. Will be removed in 3.0.0. Use isTableAvailable(TableName)
    
    Use this api to check if the table has been created with the specified number of splitkeys which was used while creating the given table. Note : If this api is used after a table's region gets splitted, the api may return false. The return value will be wrapped by a CompletableFuture.
    
    Parameters:
    
    tableName - name of table to check
    
    splitKeys - keys to check if the table has been created with all split keys
  - addColumnFamily
```
CompletableFuture<Void> addColumnFamily(TableName tableName,
                                        ColumnFamilyDescriptor columnFamily)
```
    Add a column family to an existing table.
    
    Parameters:
    
    tableName - name of the table to add column family to
    
    columnFamily - column family descriptor of column family to be added
  - deleteColumnFamily
```
CompletableFuture<Void> deleteColumnFamily(TableName tableName,
                                           byte[] columnFamily)
```
    Delete a column family from a table.
    
    Parameters:
    
    tableName - name of table
    
    columnFamily - name of column family to be deleted
  - modifyColumnFamily
```
CompletableFuture<Void> modifyColumnFamily(TableName tableName,
                                           ColumnFamilyDescriptor columnFamily)
```
    Modify an existing column family on a table.
    
    Parameters:
    
    tableName - name of table
    
    columnFamily - new column family descriptor to use
  - createNamespace
```
CompletableFuture<Void> createNamespace(NamespaceDescriptor descriptor)
```
    Create a new namespace.
    
    Parameters:
    
    descriptor - descriptor which describes the new namespace
  - modifyNamespace
```
CompletableFuture<Void> modifyNamespace(NamespaceDescriptor descriptor)
```
    Modify an existing namespace.
    
    Parameters:
    
    descriptor - descriptor which describes the new namespace
  - deleteNamespace
```
CompletableFuture<Void> deleteNamespace(String name)
```
    Delete an existing namespace. Only empty namespaces (no tables) can be removed.
    
    Parameters:
    
    name - namespace name
  - getNamespaceDescriptor
```
CompletableFuture<NamespaceDescriptor> getNamespaceDescriptor(String name)
```
    Get a namespace descriptor by name
    
    Parameters:
    
    name - name of namespace descriptor
    
    Returns:
    
    A descriptor wrapped by a CompletableFuture.
  - listNamespaceDescriptors
```
CompletableFuture<List<NamespaceDescriptor>> listNamespaceDescriptors()
```
    List available namespace descriptors
    
    Returns:
    
    List of descriptors wrapped by a CompletableFuture.
  - getRegions
```
CompletableFuture<List<RegionInfo>> getRegions(ServerName serverName)
```
    Get all the online regions on a region server.
  - getRegions
```
CompletableFuture<List<RegionInfo>> getRegions(TableName tableName)
```
    Get the regions of a given table.
  - flush
```
CompletableFuture<Void> flush(TableName tableName)
```
    Flush a table.
    
    Parameters:
    
    tableName - table to flush
  - flushRegion
```
CompletableFuture<Void> flushRegion(byte[] regionName)
```
    Flush an individual region.
    
    Parameters:
    
    regionName - region to flush
  - flushRegionServer
```
CompletableFuture<Void> flushRegionServer(ServerName serverName)
```
    Flush all region on the region server.
    
    Parameters:
    
    serverName - server to flush
  - compact
```
default CompletableFuture<Void> compact(TableName tableName)
```
    Compact a table. When the returned CompletableFuture is done, it only means the compact request was sent to HBase and may need some time to finish the compact operation. Throws TableNotFoundException if table not found.
    
    Parameters:
    
    tableName - table to compact
  - compact
```
default CompletableFuture<Void> compact(TableName tableName,
                                        byte[] columnFamily)
```
    Compact a column family within a table. When the returned CompletableFuture is done, it only means the compact request was sent to HBase and may need some time to finish the compact operation. Throws TableNotFoundException if table not found.
    
    Parameters:
    
    tableName - table to compact
    
    columnFamily - column family within a table. If not present, compact the table's all column families.
  - compact
```
CompletableFuture<Void> compact(TableName tableName,
                                CompactType compactType)
```
    Compact a table. When the returned CompletableFuture is done, it only means the compact request was sent to HBase and may need some time to finish the compact operation. Throws TableNotFoundException if table not found for normal compaction type.
    
    Parameters:
    
    tableName - table to compact
    
    compactType - CompactType
  - compact
```
CompletableFuture<Void> compact(TableName tableName,
                                byte[] columnFamily,
                                CompactType compactType)
```
    Compact a column family within a table. When the returned CompletableFuture is done, it only means the compact request was sent to HBase and may need some time to finish the compact operation. Throws TableNotFoundException if table not found for normal compaction type.
    
    Parameters:
    
    tableName - table to compact
    
    columnFamily - column family within a table
    
    compactType - CompactType
  - compactRegion
```
CompletableFuture<Void> compactRegion(byte[] regionName)
```
    Compact an individual region. When the returned CompletableFuture is done, it only means the compact request was sent to HBase and may need some time to finish the compact operation.
    
    Parameters:
    
    regionName - region to compact
  - compactRegion
```
CompletableFuture<Void> compactRegion(byte[] regionName,
                                      byte[] columnFamily)
```
    Compact a column family within a region. When the returned CompletableFuture is done, it only means the compact request was sent to HBase and may need some time to finish the compact operation.
    
    Parameters:
    
    regionName - region to compact
    
    columnFamily - column family within a region. If not present, compact the region's all column families.
  - majorCompact
```
default CompletableFuture<Void> majorCompact(TableName tableName)
```
    Major compact a table. When the returned CompletableFuture is done, it only means the compact request was sent to HBase and may need some time to finish the compact operation. Throws TableNotFoundException if table not found.
    
    Parameters:
    
    tableName - table to major compact
  - majorCompact
```
default CompletableFuture<Void> majorCompact(TableName tableName,
                                             byte[] columnFamily)
```
    Major compact a column family within a table. When the returned CompletableFuture is done, it only means the compact request was sent to HBase and may need some time to finish the compact operation. Throws TableNotFoundException if table not found for normal compaction. type.
    
    Parameters:
    
    tableName - table to major compact
    
    columnFamily - column family within a table. If not present, major compact the table's all column families.
  - majorCompact
```
CompletableFuture<Void> majorCompact(TableName tableName,
                                     CompactType compactType)
```
    Major compact a table. When the returned CompletableFuture is done, it only means the compact request was sent to HBase and may need some time to finish the compact operation. Throws TableNotFoundException if table not found for normal compaction type.
    
    Parameters:
    
    tableName - table to major compact
    
    compactType - CompactType
  - majorCompact
```
CompletableFuture<Void> majorCompact(TableName tableName,
                                     byte[] columnFamily,
                                     CompactType compactType)
```
    Major compact a column family within a table. When the returned CompletableFuture is done, it only means the compact request was sent to HBase and may need some time to finish the compact operation. Throws TableNotFoundException if table not found.
    
    Parameters:
    
    tableName - table to major compact
    
    columnFamily - column family within a table. If not present, major compact the table's all column families.
    
    compactType - CompactType
  - majorCompactRegion
```
CompletableFuture<Void> majorCompactRegion(byte[] regionName)
```
    Major compact a region. When the returned CompletableFuture is done, it only means the compact request was sent to HBase and may need some time to finish the compact operation.
    
    Parameters:
    
    regionName - region to major compact
  - majorCompactRegion
```
CompletableFuture<Void> majorCompactRegion(byte[] regionName,
                                           byte[] columnFamily)
```
    Major compact a column family within region. When the returned CompletableFuture is done, it only means the compact request was sent to HBase and may need some time to finish the compact operation.
    
    Parameters:
    
    regionName - region to major compact
    
    columnFamily - column family within a region. If not present, major compact the region's all column families.
  - compactRegionServer
```
CompletableFuture<Void> compactRegionServer(ServerName serverName)
```
    Compact all regions on the region server.
    
    Parameters:
    
    serverName - the region server name
  - majorCompactRegionServer
```
CompletableFuture<Void> majorCompactRegionServer(ServerName serverName)
```
    Compact all regions on the region server.
    
    Parameters:
    
    serverName - the region server name
  - mergeSwitch
```
default CompletableFuture<Boolean> mergeSwitch(boolean enabled)
```
    Turn the Merge switch on or off.
    
    Parameters:
    
    enabled - enabled or not
    
    Returns:
    
    Previous switch value wrapped by a CompletableFuture
  - mergeSwitch
```
CompletableFuture<Boolean> mergeSwitch(boolean enabled,
                                       boolean drainMerges)
```
    Turn the Merge switch on or off.
    Notice that, the method itself is always non-blocking, which means it will always return immediately. The drainMerges parameter only effects when will we complete the returned CompletableFuture.
    
    Parameters:
    
    enabled - enabled or not
    
    drainMerges - If true, it waits until current merge() call, if outstanding, to return.
    
    Returns:
    
    Previous switch value wrapped by a CompletableFuture
  - isMergeEnabled
```
CompletableFuture<Boolean> isMergeEnabled()
```
    Query the current state of the Merge switch.
    
    Returns:
    
    true if the switch is on, false otherwise. The return value will be wrapped by a CompletableFuture
  - splitSwitch
```
default CompletableFuture<Boolean> splitSwitch(boolean enabled)
```
    Turn the Split switch on or off.
    
    Parameters:
    
    enabled - enabled or not
    
    Returns:
    
    Previous switch value wrapped by a CompletableFuture
  - splitSwitch
```
CompletableFuture<Boolean> splitSwitch(boolean enabled,
                                       boolean drainSplits)
```
    Turn the Split switch on or off.
    Notice that, the method itself is always non-blocking, which means it will always return immediately. The drainSplits parameter only effects when will we complete the returned CompletableFuture.
    
    Parameters:
    
    enabled - enabled or not
    
    drainSplits - If true, it waits until current split() call, if outstanding, to return.
    
    Returns:
    
    Previous switch value wrapped by a CompletableFuture
  - isSplitEnabled
```
CompletableFuture<Boolean> isSplitEnabled()
```
    Query the current state of the Split switch.
    
    Returns:
    
    true if the switch is on, false otherwise. The return value will be wrapped by a CompletableFuture
  - mergeRegions
```
default CompletableFuture<Void> mergeRegions(byte[] nameOfRegionA,
                                             byte[] nameOfRegionB,
                                             boolean forcible)
```
    Merge two regions.
    
    Parameters:
    
    nameOfRegionA - encoded or full name of region a
    
    nameOfRegionB - encoded or full name of region b
    
    forcible - true if do a compulsory merge, otherwise we will only merge two adjacent regions
  - mergeRegions
```
CompletableFuture<Void> mergeRegions(List<byte[]> nameOfRegionsToMerge,
                                     boolean forcible)
```
    Merge regions.
    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.
    
    Parameters:
    
    nameOfRegionsToMerge - encoded or full name of daughter regions
    
    forcible - true if do a compulsory merge, otherwise we will only merge two adjacent regions
  - split
```
CompletableFuture<Void> split(TableName tableName)
```
    Split a table. The method will execute split action for each region in table.
    
    Parameters:
    
    tableName - table to split
  - splitRegion
```
CompletableFuture<Void> splitRegion(byte[] regionName)
```
    Split an individual region.
    
    Parameters:
    
    regionName - region to split
  - split
```
CompletableFuture<Void> split(TableName tableName,
                              byte[] splitPoint)
```
    Split a table.
    
    Parameters:
    
    tableName - table to split
    
    splitPoint - the explicit position to split on
  - splitRegion
```
CompletableFuture<Void> splitRegion(byte[] regionName,
                                    byte[] splitPoint)
```
    Split an individual region.
    
    Parameters:
    
    regionName - region to split
    
    splitPoint - the explicit position to split on. If not present, it will decide by region server.
  - assign
```
CompletableFuture<Void> assign(byte[] regionName)
```
    Parameters:
    
    regionName - Encoded or full name of region to assign.
  - unassign
```
CompletableFuture<Void> unassign(byte[] regionName,
                                 boolean forcible)
```
    Unassign a region from current hosting regionserver. Region will then be assigned to a regionserver chosen at random. Region could be reassigned back to the same server. Use move(byte[], ServerName) if you want to control the region movement.
    
    Parameters:
    
    regionName - Encoded or full name of region to unassign. Will clear any existing RegionPlan if one found.
    
    forcible - 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).
  - offline
```
CompletableFuture<Void> offline(byte[] regionName)
```
    Offline specified region from master's in-memory state. It will not attempt to reassign the region as in unassign. This API can be used when a region not served by any region server and still online as per Master's in memory state. If this API is incorrectly used on active region then master will loose track of that region. This is a special method that should be used by experts or hbck.
    
    Parameters:
    
    regionName - Encoded or full name of region to offline
  - move
```
CompletableFuture<Void> move(byte[] regionName)
```
    Move the region r to a random server.
    
    Parameters:
    
    regionName - Encoded or full name of region to move.
  - move
```
CompletableFuture<Void> move(byte[] regionName,
                             ServerName destServerName)
```
    Move the region r to dest.
    
    Parameters:
    
    regionName - Encoded or full name of region to move.
    
    destServerName - The servername of the destination regionserver. If not present, we'll assign to a random server. A server name is made of host, port and startcode. Here is an example: host187.example.com,60020,1289493121758
  - setQuota
```
CompletableFuture<Void> setQuota(QuotaSettings quota)
```
    Apply the new quota settings.
    
    Parameters:
    
    quota - the quota settings
  - getQuota
```
CompletableFuture<List<QuotaSettings>> getQuota(QuotaFilter filter)
```
    List the quotas based on the filter.
    
    Parameters:
    
    filter - the quota settings filter
    
    Returns:
    
    the QuotaSetting list, which wrapped by a CompletableFuture.
  - addReplicationPeer
```
default CompletableFuture<Void> addReplicationPeer(String peerId,
                                                   ReplicationPeerConfig peerConfig)
```
    Add a new replication peer for replicating data to slave cluster
    
    Parameters:
    
    peerId - a short name that identifies the peer
    
    peerConfig - configuration for the replication slave cluster
  - addReplicationPeer
```
CompletableFuture<Void> addReplicationPeer(String peerId,
                                           ReplicationPeerConfig peerConfig,
                                           boolean enabled)
```
    Add a new replication peer for replicating data to slave cluster
    
    Parameters:
    
    peerId - a short name that identifies the peer
    
    peerConfig - configuration for the replication slave cluster
    
    enabled - peer state, true if ENABLED and false if DISABLED
  - removeReplicationPeer
```
CompletableFuture<Void> removeReplicationPeer(String peerId)
```
    Remove a peer and stop the replication
    
    Parameters:
    
    peerId - a short name that identifies the peer
  - enableReplicationPeer
```
CompletableFuture<Void> enableReplicationPeer(String peerId)
```
    Restart the replication stream to the specified peer
    
    Parameters:
    
    peerId - a short name that identifies the peer
  - disableReplicationPeer
```
CompletableFuture<Void> disableReplicationPeer(String peerId)
```
    Stop the replication stream to the specified peer
    
    Parameters:
    
    peerId - a short name that identifies the peer
  - getReplicationPeerConfig
```
CompletableFuture<ReplicationPeerConfig> getReplicationPeerConfig(String peerId)
```
    Returns the configured ReplicationPeerConfig for the specified peer
    
    Parameters:
    
    peerId - a short name that identifies the peer
    
    Returns:
    
    ReplicationPeerConfig for the peer wrapped by a CompletableFuture.
  - updateReplicationPeerConfig
```
CompletableFuture<Void> updateReplicationPeerConfig(String peerId,
                                                    ReplicationPeerConfig peerConfig)
```
    Update the peerConfig for the specified peer
    
    Parameters:
    
    peerId - a short name that identifies the peer
    
    peerConfig - new config for the peer
  - appendReplicationPeerTableCFs
```
CompletableFuture<Void> appendReplicationPeerTableCFs(String peerId,
                                                      Map<TableName,List<String>> tableCfs)
```
    Append the replicable table-cf config of the specified peer
    
    Parameters:
    
    peerId - a short that identifies the cluster
    
    tableCfs - A map from tableName to column family names
  - removeReplicationPeerTableCFs
```
CompletableFuture<Void> removeReplicationPeerTableCFs(String peerId,
                                                      Map<TableName,List<String>> tableCfs)
```
    Remove some table-cfs from config of the specified peer
    
    Parameters:
    
    peerId - a short name that identifies the cluster
    
    tableCfs - A map from tableName to column family names
  - listReplicationPeers
```
CompletableFuture<List<ReplicationPeerDescription>> listReplicationPeers()
```
    Return a list of replication peers.
    
    Returns:
    
    a list of replication peers description. The return value will be wrapped by a CompletableFuture.
  - listReplicationPeers
```
CompletableFuture<List<ReplicationPeerDescription>> listReplicationPeers(Pattern pattern)
```
    Return a list of replication peers.
    
    Parameters:
    
    pattern - The compiled regular expression to match peer id
    
    Returns:
    
    a list of replication peers description. The return value will be wrapped by a CompletableFuture.
  - listReplicatedTableCFs
```
CompletableFuture<List<TableCFs>> listReplicatedTableCFs()
```
    Find all table and column families that are replicated from this cluster
    
    Returns:
    
    the replicated table-cfs list of this cluster. The return value will be wrapped by a CompletableFuture.
  - enableTableReplication
```
CompletableFuture<Void> enableTableReplication(TableName tableName)
```
    Enable a table's replication switch.
    
    Parameters:
    
    tableName - name of the table
  - disableTableReplication
```
CompletableFuture<Void> disableTableReplication(TableName tableName)
```
    Disable a table's replication switch.
    
    Parameters:
    
    tableName - name of the table
  - snapshot
```
default CompletableFuture<Void> snapshot(String snapshotName,
                                         TableName tableName)
```
    Take a snapshot for the given table. If the table is enabled, a FLUSH-type snapshot will be taken. If the table is disabled, an offline snapshot is taken. Snapshots are considered unique based on the name of the snapshot. Attempts to take a snapshot with the same name (even a different type or with different parameters) will fail with a SnapshotCreationException indicating the duplicate naming. Snapshot names follow the same naming constraints as tables in HBase. See TableName.isLegalFullyQualifiedTableName(byte[]).
    
    Parameters:
    
    snapshotName - name of the snapshot to be created
    
    tableName - name of the table for which snapshot is created
  - snapshot
```
default CompletableFuture<Void> snapshot(String snapshotName,
                                         TableName tableName,
                                         SnapshotType type)
```
    Create typed snapshot of the table. Snapshots are considered unique based on the name of the snapshot. Attempts to take a snapshot with the same name (even a different type or with different parameters) will fail with a SnapshotCreationException indicating the duplicate naming. Snapshot names follow the same naming constraints as tables in HBase. See TableName.isLegalFullyQualifiedTableName(byte[]).
    
    Parameters:
    
    snapshotName - name to give the snapshot on the filesystem. Must be unique from all other snapshots stored on the cluster
    
    tableName - name of the table to snapshot
    
    type - type of snapshot to take
  - snapshot
```
CompletableFuture<Void> snapshot(SnapshotDescription snapshot)
```
    Take a snapshot and wait for the server to complete that snapshot asynchronously. Only a single snapshot should be taken at a time for an instance of HBase, or results may be undefined (you can tell multiple HBase clusters to snapshot at the same time, but only one at a time for a single cluster). Snapshots are considered unique based on the name of the snapshot. Attempts to take a snapshot with the same name (even a different type or with different parameters) will fail with a SnapshotCreationException indicating the duplicate naming. Snapshot names follow the same naming constraints as tables in HBase. See TableName.isLegalFullyQualifiedTableName(byte[]). You should probably use snapshot(String, org.apache.hadoop.hbase.TableName) unless you are sure about the type of snapshot that you want to take.
    
    Parameters:
    
    snapshot - snapshot to take
  - isSnapshotFinished
```
CompletableFuture<Boolean> isSnapshotFinished(SnapshotDescription snapshot)
```
    Check the current state of the passed snapshot. There are three possible states:
    1. running - returns false
    2. finished - returns true
    3. finished with error - throws the exception that caused the snapshot to fail
    The cluster only knows about the most recent snapshot. Therefore, if another snapshot has been run/started since the snapshot you are checking, you will receive an UnknownSnapshotException.
    Parameters:
    
    snapshot - description of the snapshot to check
    
    Returns:
    
    true if the snapshot is completed, false if the snapshot is still running
  - restoreSnapshot
```
CompletableFuture<Void> restoreSnapshot(String snapshotName)
```
    Restore the specified snapshot on the original table. (The table must be disabled) If the "hbase.snapshot.restore.take.failsafe.snapshot" configuration property is set to true, a snapshot of the current table is taken before executing the restore operation. In case of restore failure, the failsafe snapshot will be restored. If the restore completes without problem the failsafe snapshot is deleted.
    
    Parameters:
    
    snapshotName - name of the snapshot to restore
  - restoreSnapshot
```
default CompletableFuture<Void> restoreSnapshot(String snapshotName,
                                                boolean takeFailSafeSnapshot)
```
    Restore the specified snapshot on the original table. (The table must be disabled) If 'takeFailSafeSnapshot' is set to true, a snapshot of the current table is taken before executing the restore operation. In case of restore failure, the failsafe snapshot will be restored. If the restore completes without problem the failsafe snapshot is deleted. The failsafe snapshot name is configurable by using the property "hbase.snapshot.restore.failsafe.name".
    
    Parameters:
    
    snapshotName - name of the snapshot to restore
    
    takeFailSafeSnapshot - true if the failsafe snapshot should be taken
  - restoreSnapshot
```
CompletableFuture<Void> restoreSnapshot(String snapshotName,
                                        boolean takeFailSafeSnapshot,
                                        boolean restoreAcl)
```
    Restore the specified snapshot on the original table. (The table must be disabled) If 'takeFailSafeSnapshot' is set to true, a snapshot of the current table is taken before executing the restore operation. In case of restore failure, the failsafe snapshot will be restored. If the restore completes without problem the failsafe snapshot is deleted. The failsafe snapshot name is configurable by using the property "hbase.snapshot.restore.failsafe.name".
    
    Parameters:
    
    snapshotName - name of the snapshot to restore
    
    takeFailSafeSnapshot - true if the failsafe snapshot should be taken
    
    restoreAcl - true to restore acl of snapshot
  - cloneSnapshot
```
default CompletableFuture<Void> cloneSnapshot(String snapshotName,
                                              TableName tableName)
```
    Create a new table by cloning the snapshot content.
    
    Parameters:
    
    snapshotName - name of the snapshot to be cloned
    
    tableName - name of the table where the snapshot will be restored
  - cloneSnapshot
```
CompletableFuture<Void> cloneSnapshot(String snapshotName,
                                      TableName tableName,
                                      boolean restoreAcl)
```
    Create a new table by cloning the snapshot content.
    
    Parameters:
    
    snapshotName - name of the snapshot to be cloned
    
    tableName - name of the table where the snapshot will be restored
    
    restoreAcl - true to restore acl of snapshot
  - listSnapshots
```
CompletableFuture<List<SnapshotDescription>> listSnapshots()
```
    List completed snapshots.
    
    Returns:
    
    a list of snapshot descriptors for completed snapshots wrapped by a CompletableFuture
  - listSnapshots
```
CompletableFuture<List<SnapshotDescription>> listSnapshots(Pattern pattern)
```
    List all the completed snapshots matching the given pattern.
    
    Parameters:
    
    pattern - The compiled regular expression to match against
    
    Returns:
    
    - returns a List of SnapshotDescription wrapped by a CompletableFuture
  - listTableSnapshots
```
CompletableFuture<List<SnapshotDescription>> listTableSnapshots(Pattern tableNamePattern)
```
    List all the completed snapshots matching the given table name pattern.
    
    Parameters:
    
    tableNamePattern - The compiled table name regular expression to match against
    
    Returns:
    
    - returns a List of completed SnapshotDescription wrapped by a CompletableFuture
  - listTableSnapshots
```
CompletableFuture<List<SnapshotDescription>> listTableSnapshots(Pattern tableNamePattern,
                                                                Pattern snapshotNamePattern)
```
    List all the completed snapshots matching the given table name regular expression and snapshot name regular expression.
    
    Parameters:
    
    tableNamePattern - The compiled table name regular expression to match against
    
    snapshotNamePattern - The compiled snapshot name regular expression to match against
    
    Returns:
    
    - returns a List of completed SnapshotDescription wrapped by a CompletableFuture
  - deleteSnapshot
```
CompletableFuture<Void> deleteSnapshot(String snapshotName)
```
    Delete an existing snapshot.
    
    Parameters:
    
    snapshotName - name of the snapshot
  - deleteSnapshots
```
CompletableFuture<Void> deleteSnapshots()
```
    Delete all existing snapshots.
  - deleteSnapshots
```
CompletableFuture<Void> deleteSnapshots(Pattern pattern)
```
    Delete existing snapshots whose names match the pattern passed.
    
    Parameters:
    
    pattern - pattern for names of the snapshot to match
  - deleteTableSnapshots
```
CompletableFuture<Void> deleteTableSnapshots(Pattern tableNamePattern)
```
    Delete all existing snapshots matching the given table name pattern.
    
    Parameters:
    
    tableNamePattern - The compiled table name regular expression to match against
  - deleteTableSnapshots
```
CompletableFuture<Void> deleteTableSnapshots(Pattern tableNamePattern,
                                             Pattern snapshotNamePattern)
```
    Delete all existing snapshots matching the given table name regular expression and snapshot name regular expression.
    
    Parameters:
    
    tableNamePattern - The compiled table name regular expression to match against
    
    snapshotNamePattern - The compiled snapshot name regular expression to match against
  - execProcedure
```
CompletableFuture<Void> execProcedure(String signature,
                                      String instance,
                                      Map<String,String> props)
```
    Execute a distributed procedure on a cluster.
    
    Parameters:
    
    signature - A distributed procedure is uniquely identified by its signature (default the root ZK node name of the procedure).
    
    instance - The instance name of the procedure. For some procedures, this parameter is optional.
    
    props - Property/Value pairs of properties passing to the procedure
  - execProcedureWithReturn
```
CompletableFuture<byte[]> execProcedureWithReturn(String signature,
                                                  String instance,
                                                  Map<String,String> props)
```
    Execute a distributed procedure on a cluster.
    
    Parameters:
    
    signature - A distributed procedure is uniquely identified by its signature (default the root ZK node name of the procedure).
    
    instance - The instance name of the procedure. For some procedures, this parameter is optional.
    
    props - Property/Value pairs of properties passing to the procedure
    
    Returns:
    
    data returned after procedure execution. null if no return data.
  - isProcedureFinished
```
CompletableFuture<Boolean> isProcedureFinished(String signature,
                                               String instance,
                                               Map<String,String> props)
```
    Check the current state of the specified procedure. There are three possible states:
    1. running - returns false
    2. finished - returns true
    3. finished with error - throws the exception that caused the procedure to fail
    Parameters:
    
    signature - The signature that uniquely identifies a procedure
    
    instance - The instance name of the procedure
    
    props - Property/Value pairs of properties passing to the procedure
    
    Returns:
    
    true if the specified procedure is finished successfully, false if it is still running. The value is wrapped by CompletableFuture
  - abortProcedure
```
@Deprecated
CompletableFuture<Boolean> abortProcedure(long procId,
                                                      boolean mayInterruptIfRunning)
```
    Deprecated. since 2.1.1 and will be removed in 4.0.0.
    
    Abort a procedure Do not use. Usually it is ignored but if not, it can do more damage than good. See hbck2.
    
    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. the value is wrapped by CompletableFuture
    
    See Also:
    
    HBASE-21223
  - getProcedures
```
CompletableFuture<String> getProcedures()
```
    List procedures
    
    Returns:
    
    procedure list JSON wrapped by CompletableFuture
  - getLocks
```
CompletableFuture<String> getLocks()
```
    List locks.
    
    Returns:
    
    lock list JSON wrapped by CompletableFuture
  - decommissionRegionServers
```
CompletableFuture<Void> decommissionRegionServers(List<ServerName> servers,
                                                  boolean offload)
```
    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.
    
    Parameters:
    
    servers - The list of servers to decommission.
    
    offload - True to offload the regions from the decommissioned servers
  - listDecommissionedRegionServers
```
CompletableFuture<List<ServerName>> listDecommissionedRegionServers()
```
    List region servers marked as decommissioned, which can not be assigned regions.
    
    Returns:
    
    List of decommissioned region servers wrapped by CompletableFuture
  - recommissionRegionServer
```
CompletableFuture<Void> recommissionRegionServer(ServerName server,
                                                 List<byte[]> encodedRegionNames)
```
    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.
    
    Parameters:
    
    server - The server to recommission.
    
    encodedRegionNames - Regions to load onto the server.
  - getClusterMetrics
```
CompletableFuture<ClusterMetrics> getClusterMetrics()
```
    Returns:
    
    cluster status wrapped by CompletableFuture
  - getClusterMetrics
```
CompletableFuture<ClusterMetrics> getClusterMetrics(EnumSet<ClusterMetrics.Option> options)
```
    Returns:
    
    cluster status wrapped by CompletableFuture
  - getMaster
```
default CompletableFuture<ServerName> getMaster()
```
    Returns:
    
    current master server name wrapped by CompletableFuture
  - getBackupMasters
```
default CompletableFuture<Collection<ServerName>> getBackupMasters()
```
    Returns:
    
    current backup master list wrapped by CompletableFuture
  - getRegionServers
```
default CompletableFuture<Collection<ServerName>> getRegionServers()
```
    Returns:
    
    current live region servers list wrapped by CompletableFuture
  - getMasterCoprocessorNames
```
default CompletableFuture<List<String>> getMasterCoprocessorNames()
```
    Returns:
    
    a list of master coprocessors wrapped by CompletableFuture
  - getMasterInfoPort
```
default CompletableFuture<Integer> getMasterInfoPort()
```
    Get the info port of the current master if one is available.
    
    Returns:
    
    master info port
  - shutdown
```
CompletableFuture<Void> shutdown()
```
    Shuts down the HBase cluster.
  - stopMaster
```
CompletableFuture<Void> stopMaster()
```
    Shuts down the current HBase master only.
  - stopRegionServer
```
CompletableFuture<Void> stopRegionServer(ServerName serverName)
```
    Stop the designated regionserver.
    
    Parameters:
    
    serverName -
  - updateConfiguration
```
CompletableFuture<Void> updateConfiguration(ServerName serverName)
```
    Update the configuration and trigger an online config change on the regionserver.
    
    Parameters:
    
    serverName - : The server whose config needs to be updated.
  - updateConfiguration
```
CompletableFuture<Void> updateConfiguration()
```
    Update the configuration and trigger an online config change on all the masters and regionservers.
  - rollWALWriter
```
CompletableFuture<Void> rollWALWriter(ServerName serverName)
```
    Roll the log writer. I.e. for filesystem based write ahead logs, start writing to a new file.
    When the returned CompletableFuture is done, it only means the rollWALWriter request was sent to the region server and may need some time to finish the rollWALWriter operation. As a side effect of this call, the named region server may schedule store flushes at the request of the wal.
    
    Parameters:
    
    serverName - The servername of the region server.
  - clearCompactionQueues
```
CompletableFuture<Void> clearCompactionQueues(ServerName serverName,
                                              Set<String> queues)
```
    Clear compacting queues on a region server.
    
    Parameters:
    
    serverName -
    
    queues - the set of queue name
  - getRegionMetrics
```
CompletableFuture<List<RegionMetrics>> getRegionMetrics(ServerName serverName)
```
    Get a list of RegionMetrics of all regions hosted on a region seerver.
    
    Parameters:
    
    serverName -
    
    Returns:
    
    a list of RegionMetrics wrapped by CompletableFuture
  - getRegionMetrics
```
CompletableFuture<List<RegionMetrics>> getRegionMetrics(ServerName serverName,
                                                        TableName tableName)
```
    Get a list of RegionMetrics of all regions hosted on a region seerver for a table.
    
    Parameters:
    
    serverName -
    
    tableName -
    
    Returns:
    
    a list of RegionMetrics wrapped by CompletableFuture
  - isMasterInMaintenanceMode
```
CompletableFuture<Boolean> isMasterInMaintenanceMode()
```
    Check whether master is in maintenance mode
    
    Returns:
    
    true if master is in maintenance mode, false otherwise. The return value will be wrapped by a CompletableFuture
  - getCompactionState
```
default CompletableFuture<CompactionState> getCompactionState(TableName tableName)
```
    Get the current compaction state of a table. It could be in a major compaction, a minor compaction, both, or none.
    
    Parameters:
    
    tableName - table to examine
    
    Returns:
    
    the current compaction state wrapped by a CompletableFuture
  - getCompactionState
```
CompletableFuture<CompactionState> getCompactionState(TableName tableName,
                                                      CompactType compactType)
```
    Get the current compaction state of a table. It could be in a major compaction, a minor compaction, both, or none.
    
    Parameters:
    
    tableName - table to examine
    
    compactType - CompactType
    
    Returns:
    
    the current compaction state wrapped by a CompletableFuture
  - getCompactionStateForRegion
```
CompletableFuture<CompactionState> getCompactionStateForRegion(byte[] regionName)
```
    Get the current compaction state of region. It could be in a major compaction, a minor compaction, both, or none.
    
    Parameters:
    
    regionName - region to examine
    
    Returns:
    
    the current compaction state wrapped by a CompletableFuture
  - getLastMajorCompactionTimestamp
```
CompletableFuture<Optional<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 not present if no such HFile could be found.
    
    Parameters:
    
    tableName - table to examine
    
    Returns:
    
    the last major compaction timestamp wrapped by a CompletableFuture
  - getLastMajorCompactionTimestampForRegion
```
CompletableFuture<Optional<Long>> getLastMajorCompactionTimestampForRegion(byte[] regionName)
```
    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 not present if no such HFile could be found.
    
    Parameters:
    
    regionName - region to examine
    
    Returns:
    
    the last major compaction timestamp wrapped by a CompletableFuture
  - getSecurityCapabilities
```
CompletableFuture<List<SecurityCapability>> getSecurityCapabilities()
```
    Returns:
    
    the list of supported security capabilities. The return value will be wrapped by a CompletableFuture.
  - balancerSwitch
```
default CompletableFuture<Boolean> balancerSwitch(boolean on)
```
    Turn the load balancer on or off.
    
    Parameters:
    
    on - Set to true to enable, false to disable.
    
    Returns:
    
    Previous balancer value wrapped by a CompletableFuture.
  - balancerSwitch
```
CompletableFuture<Boolean> balancerSwitch(boolean on,
                                          boolean drainRITs)
```
    Turn the load balancer on or off.
    Notice that, the method itself is always non-blocking, which means it will always return immediately. The drainRITs parameter only effects when will we complete the returned CompletableFuture.
    
    Parameters:
    
    on - Set to true to enable, false to disable.
    
    drainRITs - If true, it waits until current balance() call, if outstanding, to return.
    
    Returns:
    
    Previous balancer value wrapped by a CompletableFuture.
  - balance
```
default CompletableFuture<Boolean> balance()
```
    Invoke the balancer. Will run the balancer and if regions to move, it will go ahead and do the reassignments. Can NOT run for various reasons. Check logs.
    
    Returns:
    
    True if balancer ran, false otherwise. The return value will be wrapped by a CompletableFuture.
  - balance
```
CompletableFuture<Boolean> balance(boolean forcible)
```
    Invoke the balancer. Will run the balancer and if regions to move, it will go ahead and do the reassignments. If there is region in transition, force parameter of true would still run balancer. Can *not* run for other reasons. Check logs.
    
    Parameters:
    
    forcible - whether we should force balance even if there is region in transition.
    
    Returns:
    
    True if balancer ran, false otherwise. The return value will be wrapped by a CompletableFuture.
  - isBalancerEnabled
```
CompletableFuture<Boolean> isBalancerEnabled()
```
    Query the current state of the balancer.
    
    Returns:
    
    true if the balance switch is on, false otherwise. The return value will be wrapped by a CompletableFuture.
  - normalizerSwitch
```
CompletableFuture<Boolean> normalizerSwitch(boolean on)
```
    Set region normalizer on/off.
    
    Parameters:
    
    on - whether normalizer should be on or off
    
    Returns:
    
    Previous normalizer value wrapped by a CompletableFuture
  - isNormalizerEnabled
```
CompletableFuture<Boolean> isNormalizerEnabled()
```
    Query the current state of the region normalizer
    
    Returns:
    
    true if region normalizer is on, false otherwise. The return value will be wrapped by a CompletableFuture
  - normalize
```
CompletableFuture<Boolean> normalize()
```
    Invoke region normalizer. Can NOT run for various reasons. Check logs.
    
    Returns:
    
    true if region normalizer ran, false otherwise. The return value will be wrapped by a CompletableFuture
  - cleanerChoreSwitch
```
CompletableFuture<Boolean> cleanerChoreSwitch(boolean on)
```
    Turn the cleaner chore on/off.
    
    Parameters:
    
    on -
    
    Returns:
    
    Previous cleaner state wrapped by a CompletableFuture
  - isCleanerChoreEnabled
```
CompletableFuture<Boolean> isCleanerChoreEnabled()
```
    Query the current state of the cleaner chore.
    
    Returns:
    
    true if cleaner chore is on, false otherwise. The return value will be wrapped by a CompletableFuture
  - runCleanerChore
```
CompletableFuture<Boolean> runCleanerChore()
```
    Ask for cleaner chore to run.
    
    Returns:
    
    true if cleaner chore ran, false otherwise. The return value will be wrapped by a CompletableFuture
  - catalogJanitorSwitch
```
CompletableFuture<Boolean> catalogJanitorSwitch(boolean on)
```
    Turn the catalog janitor on/off.
    
    Parameters:
    
    on -
    
    Returns:
    
    the previous state wrapped by a CompletableFuture
  - isCatalogJanitorEnabled
```
CompletableFuture<Boolean> isCatalogJanitorEnabled()
```
    Query on the catalog janitor state.
    
    Returns:
    
    true if the catalog janitor is on, false otherwise. The return value will be wrapped by a CompletableFuture
  - runCatalogJanitor
```
CompletableFuture<Integer> runCatalogJanitor()
```
    Ask for a scan of the catalog table.
    
    Returns:
    
    the number of entries cleaned. The return value will be wrapped by a CompletableFuture
  - coprocessorService
```
<S,R> CompletableFuture<R> coprocessorService(Function<com.google.protobuf.RpcChannel,S> stubMaker,
                                              ServiceCaller<S,R> callable)
```
    Execute the given coprocessor call on the master.
    The stubMaker is just a delegation to the newStub call. Usually it is only a one line lambda expression, like:
```
 
 channel -> xxxService.newStub(channel)
 
 
```
    Type Parameters:
    
    S - the type of the asynchronous stub
    
    R - the type of the return value
    
    Parameters:
    
    stubMaker - a delegation to the actual newStub call.
    
    callable - a delegation to the actual protobuf rpc call. See the comment of ServiceCaller for more details.
    
    Returns:
    
    the return value of the protobuf rpc call, wrapped by a CompletableFuture.
    
    See Also:
    
    ServiceCaller
  - coprocessorService
```
<S,R> CompletableFuture<R> coprocessorService(Function<com.google.protobuf.RpcChannel,S> stubMaker,
                                              ServiceCaller<S,R> callable,
                                              ServerName serverName)
```
    Execute the given coprocessor call on the given region server.
    The stubMaker is just a delegation to the newStub call. Usually it is only a one line lambda expression, like:
```
 
 channel -> xxxService.newStub(channel)
 
 
```
    Type Parameters:
    
    S - the type of the asynchronous stub
    
    R - the type of the return value
    
    Parameters:
    
    stubMaker - a delegation to the actual newStub call.
    
    callable - a delegation to the actual protobuf rpc call. See the comment of ServiceCaller for more details.
    
    serverName - the given region server
    
    Returns:
    
    the return value of the protobuf rpc call, wrapped by a CompletableFuture.
    
    See Also:
    
    ServiceCaller
  - listDeadServers
```
default CompletableFuture<List<ServerName>> listDeadServers()
```
    List all the dead region servers.
  - clearDeadServers
```
CompletableFuture<List<ServerName>> clearDeadServers(List<ServerName> servers)
```
    Clear dead region servers from master.
    
    Parameters:
    
    servers - list of dead region servers.
    
    Returns:
    
    - returns a list of servers that not cleared wrapped by a CompletableFuture.
  - clearBlockCache
```
CompletableFuture<CacheEvictionStats> clearBlockCache(TableName tableName)
```
    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.
    
    Parameters:
    
    tableName - table to clear block cache
    
    Returns:
    
    CacheEvictionStats related to the eviction wrapped by a CompletableFuture.
  - cloneTableSchema
```
CompletableFuture<Void> cloneTableSchema(TableName tableName,
                                         TableName newTableName,
                                         boolean preserveSplits)
```
    Create a new table by cloning the existent table schema.
    
    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
  - compactionSwitch
```
CompletableFuture<Map<ServerName,Boolean>> compactionSwitch(boolean switchState,
                                                            List<String> serverNamesList)
```
    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.
    
    Parameters:
    
    switchState - Set to true to enable, false to disable.
    
    serverNamesList - list of region servers.
    
    Returns:
    
    Previous compaction states for region servers
  - switchRpcThrottle
```
CompletableFuture<Boolean> switchRpcThrottle(boolean enable)
```
    Switch the rpc throttle enabled state.
    
    Parameters:
    
    enable - Set to true to enable, false to disable.
    
    Returns:
    
    Previous rpc throttle enabled value
  - isRpcThrottleEnabled
```
CompletableFuture<Boolean> isRpcThrottleEnabled()
```
    Get if the rpc throttle is enabled.
    
    Returns:
    
    True if rpc throttle is enabled
  - exceedThrottleQuotaSwitch
```
CompletableFuture<Boolean> exceedThrottleQuotaSwitch(boolean enable)
```
    Switch the exceed throttle quota. If enabled, user/table/namespace throttle quota can be exceeded if region server has availble quota.
    
    Parameters:
    
    enable - Set to true to enable, false to disable.
    
    Returns:
    
    Previous exceed throttle enabled value
  - getSpaceQuotaTableSizes
```
CompletableFuture<Map<TableName,Long>> getSpaceQuotaTableSizes()
```
    Fetches the table sizes on the filesystem as tracked by the HBase Master.
  - getRegionServerSpaceQuotaSnapshots
```
CompletableFuture<? extends Map<TableName,? extends SpaceQuotaSnapshotView>> getRegionServerSpaceQuotaSnapshots(ServerName serverName)
```
    Fetches the observed SpaceQuotaSnapshotViews observed by a RegionServer.
  - getCurrentSpaceQuotaSnapshot
```
CompletableFuture<? extends 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.
  - getCurrentSpaceQuotaSnapshot
```
CompletableFuture<? extends 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.
  - grant
```
CompletableFuture<Void> grant(UserPermission userPermission,
                              boolean mergeExistingPermissions)
```
    Grants user specific permissions
    
    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.
  - revoke
```
CompletableFuture<Void> revoke(UserPermission userPermission)
```
    Revokes user specific permissions
    
    Parameters:
    
    userPermission - user name and the specific permission
  - getUserPermissions
```
CompletableFuture<List<UserPermission>> getUserPermissions(GetUserPermissionsRequest getUserPermissionsRequest)
```
    Get the global/namespace/table permissions for user
    
    Parameters:
    
    getUserPermissionsRequest - A request contains which user, global, namespace or table permissions needed
    
    Returns:
    
    The user and permission list
  - hasUserPermissions
```
CompletableFuture<List<Boolean>> hasUserPermissions(String userName,
                                                    List<Permission> permissions)
```
    Check if the user has specific permissions
    
    Parameters:
    
    userName - the user name
    
    permissions - the specific permission list
    
    Returns:
    
    True if user has the specific permissions
  - hasUserPermissions
```
default CompletableFuture<List<Boolean>> hasUserPermissions(List<Permission> permissions)
```
    Check if call user has specific permissions
    
    Parameters:
    
    permissions - the specific permission list
    
    Returns:
    
    True if user has the specific permissions

Interface AsyncAdmin

Method Summary

Method Detail

tableExists

listTableDescriptors

listTableDescriptors

listTableDescriptors

listTableDescriptors

listTableDescriptorsByNamespace

listTableNames

listTableNames

listTableNames

listTableNamesByNamespace

getDescriptor

createTable

createTable

createTable

modifyTable

deleteTable

truncateTable

enableTable

disableTable

isTableEnabled

isTableDisabled

isTableAvailable

isTableAvailable

addColumnFamily

deleteColumnFamily

modifyColumnFamily

createNamespace

modifyNamespace

deleteNamespace

getNamespaceDescriptor

listNamespaceDescriptors

getRegions

getRegions

flush

flushRegion

flushRegionServer

compact

compact

compact

compact

compactRegion

compactRegion

majorCompact

majorCompact

majorCompact

majorCompact

majorCompactRegion

majorCompactRegion

compactRegionServer

majorCompactRegionServer

mergeSwitch

mergeSwitch

isMergeEnabled

splitSwitch

splitSwitch

isSplitEnabled

mergeRegions

mergeRegions

split

splitRegion

split

splitRegion

assign

unassign

offline

move

move

setQuota

getQuota

addReplicationPeer

addReplicationPeer

removeReplicationPeer

enableReplicationPeer

disableReplicationPeer

getReplicationPeerConfig

updateReplicationPeerConfig

appendReplicationPeerTableCFs