RawAsyncHBaseAdmin (Apache HBase 2.5.0 API)

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

All Implemented Interfaces:

AsyncAdmin
```
@InterfaceAudience.Private
class RawAsyncHBaseAdmin
extends Object
implements AsyncAdmin
```
The implementation of AsyncAdmin.
The word 'Raw' means that this is a low level class. The returned CompletableFuture will be finished inside the rpc framework thread, which means that the callbacks registered to the CompletableFuture will also be executed inside the rpc framework thread. So users who use this class should not try to do time consuming tasks in the callbacks.

Since:

2.0.0

See Also:

AsyncHBaseAdmin, AsyncConnection.getAdmin(), AsyncConnection.getAdminBuilder()

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`private static class`	`RawAsyncHBaseAdmin.AddColumnFamilyProcedureBiConsumer`
`private static interface`	`RawAsyncHBaseAdmin.AdminRpcCall<RESP,REQ>`
`private static interface`	`RawAsyncHBaseAdmin.Converter<D,S>`
`private static class`	`RawAsyncHBaseAdmin.CreateNamespaceProcedureBiConsumer`
`private static class`	`RawAsyncHBaseAdmin.CreateTableProcedureBiConsumer`
`private static class`	`RawAsyncHBaseAdmin.DeleteColumnFamilyProcedureBiConsumer`
`private static class`	`RawAsyncHBaseAdmin.DeleteNamespaceProcedureBiConsumer`
`private class`	`RawAsyncHBaseAdmin.DeleteTableProcedureBiConsumer`
`private static class`	`RawAsyncHBaseAdmin.DisableTableProcedureBiConsumer`
`private static class`	`RawAsyncHBaseAdmin.EnableTableProcedureBiConsumer`
`private static interface`	`RawAsyncHBaseAdmin.MasterRpcCall<RESP,REQ>`
`private static class`	`RawAsyncHBaseAdmin.MergeTableRegionProcedureBiConsumer`
`private static class`	`RawAsyncHBaseAdmin.ModifyColumnFamilyProcedureBiConsumer`
`private static class`	`RawAsyncHBaseAdmin.ModifyColumnFamilyStoreFileTrackerProcedureBiConsumer`
`private static class`	`RawAsyncHBaseAdmin.ModifyNamespaceProcedureBiConsumer`
`private static class`	`RawAsyncHBaseAdmin.ModifyTableProcedureBiConsumer`
`private static class`	`RawAsyncHBaseAdmin.ModifyTableStoreFileTrackerProcedureBiConsumer`
`private static class`	`RawAsyncHBaseAdmin.NamespaceProcedureBiConsumer`
`private static class`	`RawAsyncHBaseAdmin.ProcedureBiConsumer`
`private static class`	`RawAsyncHBaseAdmin.ReplicationProcedureBiConsumer`
`private static class`	`RawAsyncHBaseAdmin.SplitTableRegionProcedureBiConsumer`
`private static class`	`RawAsyncHBaseAdmin.TableProcedureBiConsumer`
`private static class`	`RawAsyncHBaseAdmin.TruncateTableProcedureBiConsumer`

Field Summary

Fields
Modifier and Type	Field and Description
`private AsyncConnectionImpl`	`connection`
`static String`	`FLUSH_TABLE_PROCEDURE_SIGNATURE`
`private static org.slf4j.Logger`	`LOG`
`private int`	`maxAttempts`
`private AsyncTable<AdvancedScanResultConsumer>`	`metaTable`
`private NonceGenerator`	`ng`
`private long`	`operationTimeoutNs`
`private long`	`pauseNs`
`private long`	`pauseNsForServerOverloaded`
`private org.apache.hbase.thirdparty.io.netty.util.HashedWheelTimer`	`retryTimer`
`private long`	`rpcTimeoutNs`
`private int`	`startLogErrorsCnt`

Constructor Summary

Constructors
Constructor and Description
`RawAsyncHBaseAdmin(AsyncConnectionImpl connection, org.apache.hbase.thirdparty.io.netty.util.HashedWheelTimer retryTimer, AsyncAdminBuilderBase builder)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`CompletableFuture<Boolean>`	`abortProcedure(long procId, boolean mayInterruptIfRunning)` Abort a procedure Do not use.
`CompletableFuture<Void>`	`addColumnFamily(TableName tableName, ColumnFamilyDescriptor columnFamily)` Add a column family to an existing table.
`CompletableFuture<Void>`	`addReplicationPeer(String peerId, ReplicationPeerConfig peerConfig, boolean enabled)` Add a new replication peer for replicating data to slave cluster
`private <PREQ,PRESP,RESP> CompletableFuture<RESP>`	`adminCall(HBaseRpcController controller, org.apache.hadoop.hbase.shaded.protobuf.generated.AdminProtos.AdminService.Interface stub, PREQ preq, RawAsyncHBaseAdmin.AdminRpcCall<PRESP,PREQ> rpcCall, RawAsyncHBaseAdmin.Converter<RESP,PRESP> respConverter)`
`CompletableFuture<Void>`	`appendReplicationPeerTableCFs(String id, Map<TableName,List<String>> tableCfs)` Append the replicable table-cf config of the specified peer
`CompletableFuture<Void>`	`assign(byte[] regionName)` Assign an individual region.
`CompletableFuture<BalanceResponse>`	`balance(BalanceRequest request)` Invoke the balancer with the given balance request.
`CompletableFuture<Boolean>`	`balancerSwitch(boolean on, boolean drainRITs)` Turn the load balancer on or off.
`private <PREQ,PRESP,RESP> CompletableFuture<RESP>`	`call(HBaseRpcController controller, org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProtos.MasterService.Interface stub, PREQ preq, RawAsyncHBaseAdmin.MasterRpcCall<PRESP,PREQ> rpcCall, RawAsyncHBaseAdmin.Converter<RESP,PRESP> respConverter)`
`CompletableFuture<Boolean>`	`catalogJanitorSwitch(boolean enabled)` Turn the catalog janitor on/off.
`private void`	`checkAndGetTableName(byte[] encodeRegionName, AtomicReference<TableName> tableName, CompletableFuture<TableName> result)`
`private CompletableFuture<Void>`	`checkAndSyncTableToPeerClusters(TableName tableName, byte[][] splits)` Connect to peer and check the table descriptor on peer: Create the same table on peer when not exist. Throw an exception if the table already has replication enabled on any of the column families. Throw an exception if the table exists on peer cluster but descriptors are not same.
`private CompletableFuture<TableName>`	`checkRegionsAndGetTableName(byte[][] encodedRegionNames)`
`CompletableFuture<Boolean>`	`cleanerChoreSwitch(boolean enabled)` Turn the cleaner chore on/off.
`private CompletableFuture<CacheEvictionStats>`	`clearBlockCache(ServerName serverName, List<RegionInfo> hris)`
`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.
`CompletableFuture<List<Boolean>>`	`clearSlowLogResponses(Set<ServerName> serverNames)` Clears online slow RPC logs from the provided list of RegionServers
`private CompletableFuture<Boolean>`	`clearSlowLogsResponses(ServerName serverName)`
`CompletableFuture<Void>`	`cloneSnapshot(String snapshotName, TableName tableName, boolean restoreAcl, String customSFT)` 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.
`private CompletableFuture<Void>`	`compact(ServerName sn, RegionInfo hri, boolean major, byte[] columnFamily)` Compact the region at specific region server.
`private CompletableFuture<Void>`	`compact(TableName tableName, byte[] columnFamily, boolean major, CompactType compactType)` Compact column family of a table, Asynchronous operation even if CompletableFuture.get()
`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.
`private CompletableFuture<Void>`	`compactRegion(byte[] regionName, byte[] columnFamily, boolean major)`
`CompletableFuture<Void>`	`compactRegionServer(ServerName sn)` Compact all regions on the region server.
`private CompletableFuture<Void>`	`compactRegionServer(ServerName sn, boolean major)`
`private boolean`	`compareRegionsWithSplitKeys(List<HRegionLocation> locations, byte[][] splitKeys)`
`private CompletableFuture<Void>`	`compareTableWithPeerCluster(TableName tableName, TableDescriptor tableDesc, ReplicationPeerDescription peer, AsyncAdmin peerAdmin)`
`private static CompletableFuture<Boolean>`	`completeCheckTableState(CompletableFuture<Boolean> future, TableState tableState, Throwable error, TableState.State targetState, TableName tableName)` Utility for completing passed TableState `CompletableFuture` `future` using passed parameters.
`private <T> void`	`completeConditionalOnFuture(CompletableFuture<T> dependentFuture, CompletableFuture<T> parentFuture)`
`private <T> boolean`	`completeExceptionally(CompletableFuture<T> future, Throwable error)`
`private static <T> CompletableFuture<List<T>>`	`convertToFutureOfList(List<CompletableFuture<T>> futures)`
`<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.
`private CompletableFuture<Void>`	`createTable(TableName tableName, org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProtos.CreateTableRequest request)`
`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 snapshotNamePattern)` 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.
`private <T> CompletableFuture<T>`	`failedFuture(Throwable error)`
`private CompletableFuture<Void>`	`flush(ServerName serverName, RegionInfo regionInfo, byte[] columnFamily)`
`CompletableFuture<Void>`	`flush(TableName tableName)` Flush a table.
`CompletableFuture<Void>`	`flush(TableName tableName, byte[] columnFamily)` Flush the specified column family stores on all regions of the passed table.
`CompletableFuture<Void>`	`flushMasterStore()` Flush master local region
`CompletableFuture<Void>`	`flushRegion(byte[] regionName)` Flush an individual region.
`CompletableFuture<Void>`	`flushRegion(byte[] regionName, byte[] columnFamily)` Flush a column family within a region.
`CompletableFuture<Void>`	`flushRegionServer(ServerName sn)` Flush all region on the region server.
`private CompletableFuture<List<LogEntry>>`	`getBalancerDecisions(int limit)`
`private CompletableFuture<List<LogEntry>>`	`getBalancerRejections(int limit)`
`CompletableFuture<ClusterMetrics>`	`getClusterMetrics()` Returns cluster status wrapped by `CompletableFuture`
`CompletableFuture<ClusterMetrics>`	`getClusterMetrics(EnumSet<ClusterMetrics.Option> options)` Returns cluster status wrapped by `CompletableFuture`
`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.
`private CompletableFuture<List<SnapshotDescription>>`	`getCompletedSnapshots(Pattern pattern)`
`private CompletableFuture<List<SnapshotDescription>>`	`getCompletedSnapshots(Pattern tableNamePattern, Pattern snapshotNamePattern)`
`private CompletableFuture<SpaceQuotaSnapshot>`	`getCurrentSpaceQuotaSnapshot(RawAsyncHBaseAdmin.Converter<SpaceQuotaSnapshot,org.apache.hadoop.hbase.shaded.protobuf.generated.QuotaProtos.GetQuotaStatesResponse> converter)`
`CompletableFuture<SpaceQuotaSnapshot>`	`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<SpaceQuotaSnapshot>`	`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.
`CompletableFuture<List<LogEntry>>`	`getLogEntries(Set<ServerName> serverNames, String logType, ServerType serverType, int limit, Map<String,Object> filterParams)` Retrieve recent online records from HMaster / RegionServers.
`CompletableFuture<NamespaceDescriptor>`	`getNamespaceDescriptor(String name)` Get a namespace descriptor by name
`private void`	`getProcedureResult(long procId, CompletableFuture<Void> future, int retries)`
`CompletableFuture<String>`	`getProcedures()` List procedures
`CompletableFuture<List<QuotaSettings>>`	`getQuota(QuotaFilter filter)` List the quotas based on the filter.
`private CompletableFuture<RegionInfo>`	`getRegionInfo(byte[] regionNameOrEncodedRegionName)` Get the region info for the passed region name.
`(package private) CompletableFuture<HRegionLocation>`	`getRegionLocation(byte[] regionNameOrEncodedRegionName)` Get the region location for the passed region name.
`private CompletableFuture<List<RegionMetrics>>`	`getRegionMetrics(org.apache.hadoop.hbase.shaded.protobuf.generated.AdminProtos.GetRegionLoadRequest request, ServerName serverName)`
`CompletableFuture<List<RegionMetrics>>`	`getRegionMetrics(ServerName serverName)` Get a list of `RegionMetrics` of all regions hosted on a region server.
`CompletableFuture<List<RegionMetrics>>`	`getRegionMetrics(ServerName serverName, TableName tableName)` Get a list of `RegionMetrics` of all regions hosted on a region server 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.
`private CompletableFuture<List<ServerName>>`	`getRegionServerList(List<String> serverNamesList)`
`CompletableFuture<Map<TableName,SpaceQuotaSnapshot>>`	`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()` Returns the list of supported security capabilities.
`private CompletableFuture<List<LogEntry>>`	`getSlowLogResponseFromServer(ServerName serverName, Map<String,Object> filterParams, int limit, String logType)`
`private CompletableFuture<List<LogEntry>>`	`getSlowLogResponses(Map<String,Object> filterParams, Set<ServerName> serverNames, int limit, String logType)`
`CompletableFuture<Map<TableName,Long>>`	`getSpaceQuotaTableSizes()` Fetches the table sizes on the filesystem as tracked by the HBase Master.
`private byte[][]`	`getSplitKeys(byte[] startKey, byte[] endKey, int numRegions)`
`private CompletableFuture<List<TableDescriptor>>`	`getTableDescriptors(org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProtos.GetTableDescriptorsRequest request)`
`private CompletableFuture<List<HRegionLocation>>`	`getTableHRegionLocations(TableName tableName)` List all region locations for the specific table.
`private CompletableFuture<List<TableName>>`	`getTableNames(org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProtos.GetTableNamesRequest request)`
`private CompletableFuture<byte[][]>`	`getTableSplits(TableName tableName)`
`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
`CompletableFuture<List<Boolean>>`	`hasUserPermissions(String userName, List<Permission> permissions)` Check if the user has specific permissions
`private CompletableFuture<Void>`	`internalDeleteSnapshot(SnapshotDescription snapshot)`
`private CompletableFuture<Void>`	`internalDeleteSnapshots(Pattern tableNamePattern, Pattern snapshotNamePattern)`
`private CompletableFuture<Void>`	`internalRestoreSnapshot(String snapshotName, TableName tableName, boolean restoreAcl, String customSFT)`
`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>`	`isSnapshotCleanupEnabled()` Query the current state of the auto snapshot cleanup based on TTL.
`CompletableFuture<Boolean>`	`isSnapshotFinished(SnapshotDescription snapshot)` Check the current state of the passed snapshot.
`CompletableFuture<Boolean>`	`isSplitEnabled()` Query the current state of the Split switch.
`private CompletableFuture<Boolean>`	`isSplitOrMergeOn(MasterSwitchType switchType)`
`CompletableFuture<Boolean>`	`isTableAvailable(TableName tableName)` Check if a table is available.
`CompletableFuture<Boolean>`	`isTableAvailable(TableName tableName, byte[][] splitKeys)` Use this api to check if the table has been created with the specified number of splitkeys which was used while creating the given table.
`private CompletableFuture<Boolean>`	`isTableAvailable(TableName tableName, Optional<byte[][]> splitKeys)`
`CompletableFuture<Boolean>`	`isTableDisabled(TableName tableName)` Check if a table is disabled.
`CompletableFuture<Boolean>`	`isTableEnabled(TableName tableName)` Check if a table is enabled.
`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<String>>`	`listNamespaces()` List available namespaces
`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.
`private CompletableFuture<List<ReplicationPeerDescription>>`	`listReplicationPeers(org.apache.hadoop.hbase.shaded.protobuf.generated.ReplicationProtos.ListReplicationPeersRequest request)`
`CompletableFuture<List<SnapshotDescription>>`	`listSnapshots()` List completed snapshots.
`CompletableFuture<List<SnapshotDescription>>`	`listSnapshots(Pattern pattern)` List all the completed snapshots matching the given pattern.
`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)` `listTableDescriptors(boolean)`
`CompletableFuture<List<TableDescriptor>>`	`listTableDescriptorsByNamespace(String name)` Get list of table descriptors by namespace.
`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.
`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 sn)` Compact all regions on the region server.
`CompletableFuture<Void>`	`mergeRegions(List<byte[]> nameOfRegionsToMerge, boolean forcible)` Merge multiple regions (>=2).
`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>`	`modifyColumnFamilyStoreFileTracker(TableName tableName, byte[] family, String dstSFT)` Change the store file tracker of the given table's given family.
`CompletableFuture<Void>`	`modifyNamespace(NamespaceDescriptor descriptor)` Modify an existing namespace.
`CompletableFuture<Void>`	`modifyTable(TableDescriptor desc)` Modify an existing table, more IRB friendly version.
`CompletableFuture<Void>`	`modifyTableStoreFileTracker(TableName tableName, String dstSFT)` Change the store file tracker of the given table.
`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`.
`private CompletableFuture<Void>`	`moveRegion(RegionInfo regionInfo, org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProtos.MoveRegionRequest request)`
`private <T> AsyncRpcRetryingCallerFactory.AdminRequestCallerBuilder<T>`	`newAdminCaller()`
`private <T> AsyncRpcRetryingCallerFactory.MasterRequestCallerBuilder<T>`	`newMasterCaller()`
`private <T> AsyncRpcRetryingCallerFactory.ServerRequestCallerBuilder<T>`	`newServerCaller()`
`private CompletableFuture<Boolean>`	`normalize(org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProtos.NormalizeRequest request)`
`CompletableFuture<Boolean>`	`normalize(NormalizeTableFilterParams ntfp)` 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.
`private <PREQ,PRESP> CompletableFuture<Void>`	`procedureCall(Consumer<AsyncRpcRetryingCallerFactory.MasterRequestCallerBuilder<?>> prioritySetter, PREQ preq, RawAsyncHBaseAdmin.MasterRpcCall<PRESP,PREQ> rpcCall, RawAsyncHBaseAdmin.Converter<Long,PRESP> respConverter, RawAsyncHBaseAdmin.ProcedureBiConsumer consumer)`
`private <PREQ,PRESP> CompletableFuture<Void>`	`procedureCall(PREQ preq, RawAsyncHBaseAdmin.MasterRpcCall<PRESP,PREQ> rpcCall, RawAsyncHBaseAdmin.Converter<Long,PRESP> respConverter, RawAsyncHBaseAdmin.ProcedureBiConsumer consumer)`
`private <PREQ,PRESP> CompletableFuture<Void>`	`procedureCall(TableName tableName, PREQ preq, RawAsyncHBaseAdmin.MasterRpcCall<PRESP,PREQ> rpcCall, RawAsyncHBaseAdmin.Converter<Long,PRESP> respConverter, RawAsyncHBaseAdmin.ProcedureBiConsumer consumer)`
`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 id, 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.
`CompletableFuture<Void>`	`restoreSnapshot(String snapshotName, boolean takeFailSafeSnapshot, boolean restoreAcl)` Restore the specified snapshot on the original table.
`private CompletableFuture<Void>`	`restoreSnapshot(String snapshotName, TableName tableName, boolean takeFailSafeSnapshot, boolean restoreAcl)`
`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.
`private CompletableFuture<Boolean>`	`setSplitOrMergeOn(boolean enabled, boolean synchronous, MasterSwitchType switchType)`
`private CompletableFuture<Void>`	`setTableReplication(TableName tableName, boolean enableRep)` Set the table's replication switch if the table's replication switch is already not set.
`CompletableFuture<Void>`	`shutdown()` Shuts down the HBase cluster.
`CompletableFuture<Void>`	`snapshot(SnapshotDescription snapshotDesc)` Take a snapshot and wait for the server to complete that snapshot asynchronously.
`CompletableFuture<Boolean>`	`snapshotCleanupSwitch(boolean on, boolean sync)` Turn on or off the auto snapshot cleanup based on TTL.
`private CompletableFuture<Void>`	`split(RegionInfo hri, byte[] splitPoint)`
`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.
`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.
`private CompletableFuture<Boolean>`	`switchCompact(ServerName serverName, boolean onOrOff)`
`CompletableFuture<Boolean>`	`switchRpcThrottle(boolean enable)` Switch the rpc throttle enabled state.
`CompletableFuture<Boolean>`	`tableExists(TableName tableName)` Check if a table exists.
`private byte[]`	`toEncodeRegionName(byte[] regionName)`
`CompletableFuture<Void>`	`truncateTable(TableName tableName, boolean preserveSplits)` Truncate a table.
`private CompletableFuture<Void>`	`trySyncTableToPeerCluster(TableName tableName, byte[][] splits, ReplicationPeerDescription peer)`
`CompletableFuture<Void>`	`unassign(byte[] regionName)` 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
`private void`	`verifySplitKeys(byte[][] splitKeys)`
`private CompletableFuture<Void>`	`waitProcedureResult(CompletableFuture<Long> procFuture)`

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.AsyncAdmin
addReplicationPeer, balance, balance, balancerSwitch, cloneSnapshot, cloneSnapshot, compact, compact, getBackupMasters, getCompactionState, getMaster, getMasterCoprocessorNames, getMasterInfoPort, getRegionServers, getRegionServers, getSlowLogResponses, hasUserPermissions, listDeadServers, listTableDescriptors, listTableNames, listUnknownServers, majorCompact, majorCompact, mergeRegions, mergeSwitch, normalize, restoreSnapshot, snapshot, snapshot, splitSwitch, unassign

- Field Detail
  - FLUSH_TABLE_PROCEDURE_SIGNATURE
```
public static final String FLUSH_TABLE_PROCEDURE_SIGNATURE
```
    See Also:
    
    Constant Field Values
  - LOG
```
private static final org.slf4j.Logger LOG
```
  - connection
```
private final AsyncConnectionImpl connection
```
  - retryTimer
```
private final org.apache.hbase.thirdparty.io.netty.util.HashedWheelTimer retryTimer
```
  - metaTable
```
private final AsyncTable<AdvancedScanResultConsumer> metaTable
```
  - rpcTimeoutNs
```
private final long rpcTimeoutNs
```
  - operationTimeoutNs
```
private final long operationTimeoutNs
```
  - pauseNs
```
private final long pauseNs
```
  - pauseNsForServerOverloaded
```
private final long pauseNsForServerOverloaded
```
  - maxAttempts
```
private final int maxAttempts
```
  - startLogErrorsCnt
```
private final int startLogErrorsCnt
```
  - ng
```
private final NonceGenerator ng
```
- Constructor Detail
  - RawAsyncHBaseAdmin
```
RawAsyncHBaseAdmin(AsyncConnectionImpl connection,
                   org.apache.hbase.thirdparty.io.netty.util.HashedWheelTimer retryTimer,
                   AsyncAdminBuilderBase builder)
```
- Method Detail
  - newMasterCaller
```
private <T> AsyncRpcRetryingCallerFactory.MasterRequestCallerBuilder<T> newMasterCaller()
```
  - newAdminCaller
```
private <T> AsyncRpcRetryingCallerFactory.AdminRequestCallerBuilder<T> newAdminCaller()
```
  - call
```
private <PREQ,PRESP,RESP> CompletableFuture<RESP> call(HBaseRpcController controller,
                                                       org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProtos.MasterService.Interface stub,
                                                       PREQ preq,
                                                       RawAsyncHBaseAdmin.MasterRpcCall<PRESP,PREQ> rpcCall,
                                                       RawAsyncHBaseAdmin.Converter<RESP,PRESP> respConverter)
```
  - adminCall
```
private <PREQ,PRESP,RESP> CompletableFuture<RESP> adminCall(HBaseRpcController controller,
                                                            org.apache.hadoop.hbase.shaded.protobuf.generated.AdminProtos.AdminService.Interface stub,
                                                            PREQ preq,
                                                            RawAsyncHBaseAdmin.AdminRpcCall<PRESP,PREQ> rpcCall,
                                                            RawAsyncHBaseAdmin.Converter<RESP,PRESP> respConverter)
```
  - procedureCall
```
private <PREQ,PRESP> CompletableFuture<Void> procedureCall(PREQ preq,
                                                           RawAsyncHBaseAdmin.MasterRpcCall<PRESP,PREQ> rpcCall,
                                                           RawAsyncHBaseAdmin.Converter<Long,PRESP> respConverter,
                                                           RawAsyncHBaseAdmin.ProcedureBiConsumer consumer)
```
  - procedureCall
```
private <PREQ,PRESP> CompletableFuture<Void> procedureCall(TableName tableName,
                                                           PREQ preq,
                                                           RawAsyncHBaseAdmin.MasterRpcCall<PRESP,PREQ> rpcCall,
                                                           RawAsyncHBaseAdmin.Converter<Long,PRESP> respConverter,
                                                           RawAsyncHBaseAdmin.ProcedureBiConsumer consumer)
```
  - procedureCall
```
private <PREQ,PRESP> CompletableFuture<Void> procedureCall(Consumer<AsyncRpcRetryingCallerFactory.MasterRequestCallerBuilder<?>> prioritySetter,
                                                           PREQ preq,
                                                           RawAsyncHBaseAdmin.MasterRpcCall<PRESP,PREQ> rpcCall,
                                                           RawAsyncHBaseAdmin.Converter<Long,PRESP> respConverter,
                                                           RawAsyncHBaseAdmin.ProcedureBiConsumer consumer)
```
  - tableExists
```
public CompletableFuture<Boolean> tableExists(TableName tableName)
```
    Description copied from interface: AsyncAdmin
    
    Check if a table exists.
    
    Specified by:
    
    tableExists in interface AsyncAdmin
    
    Parameters:
    
    tableName - Table to check.
    
    Returns:
    
    True if table exists already. The return value will be wrapped by a CompletableFuture.
  - listTableDescriptors
```
public CompletableFuture<List<TableDescriptor>> listTableDescriptors(boolean includeSysTables)
```
    Description copied from interface: AsyncAdmin
    
    List all the tables.
    
    Specified by:
    
    listTableDescriptors in interface AsyncAdmin
    
    Parameters:
    
    includeSysTables - False to match only against userspace tables
    
    Returns:
    
    - returns a list of TableDescriptors wrapped by a CompletableFuture.
  - listTableDescriptors
```
public CompletableFuture<List<TableDescriptor>> listTableDescriptors(Pattern pattern,
                                                                     boolean includeSysTables)
```
    listTableDescriptors(boolean)
    
    Specified by:
    
    listTableDescriptors in interface AsyncAdmin
    
    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
```
public CompletableFuture<List<TableDescriptor>> listTableDescriptors(List<TableName> tableNames)
```
    Description copied from interface: AsyncAdmin
    
    List specific tables including system tables.
    
    Specified by:
    
    listTableDescriptors in interface AsyncAdmin
    
    Parameters:
    
    tableNames - the table list to match against
    
    Returns:
    
    - returns a list of TableDescriptors wrapped by a CompletableFuture.
  - getTableDescriptors
```
private CompletableFuture<List<TableDescriptor>> getTableDescriptors(org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProtos.GetTableDescriptorsRequest request)
```
  - listTableNames
```
public CompletableFuture<List<TableName>> listTableNames(boolean includeSysTables)
```
    Description copied from interface: AsyncAdmin
    
    List all of the names of tables.
    
    Specified by:
    
    listTableNames in interface AsyncAdmin
    
    Parameters:
    
    includeSysTables - False to match only against userspace tables
    
    Returns:
    
    a list of table names wrapped by a CompletableFuture.
  - listTableNames
```
public CompletableFuture<List<TableName>> listTableNames(Pattern pattern,
                                                         boolean includeSysTables)
```
    Description copied from interface: AsyncAdmin
    
    List all of the names of userspace tables.
    
    Specified by:
    
    listTableNames in interface AsyncAdmin
    
    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.
  - getTableNames
```
private CompletableFuture<List<TableName>> getTableNames(org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProtos.GetTableNamesRequest request)
```
  - listTableDescriptorsByNamespace
```
public CompletableFuture<List<TableDescriptor>> listTableDescriptorsByNamespace(String name)
```
    Description copied from interface: AsyncAdmin
    
    Get list of table descriptors by namespace.
    
    Specified by:
    
    listTableDescriptorsByNamespace in interface AsyncAdmin
    
    Parameters:
    
    name - namespace name
    
    Returns:
    
    returns a list of TableDescriptors wrapped by a CompletableFuture.
  - listTableNamesByNamespace
```
public CompletableFuture<List<TableName>> listTableNamesByNamespace(String name)
```
    Description copied from interface: AsyncAdmin
    
    Get list of table names by namespace.
    
    Specified by:
    
    listTableNamesByNamespace in interface AsyncAdmin
    
    Parameters:
    
    name - namespace name
    
    Returns:
    
    The list of table names in the namespace wrapped by a CompletableFuture.
  - getDescriptor
```
public CompletableFuture<TableDescriptor> getDescriptor(TableName tableName)
```
    Description copied from interface: AsyncAdmin
    
    Method for getting the tableDescriptor
    
    Specified by:
    
    getDescriptor in interface AsyncAdmin
    
    Parameters:
    
    tableName - as a TableName
    
    Returns:
    
    the read-only tableDescriptor wrapped by a CompletableFuture.
  - createTable
```
public CompletableFuture<Void> createTable(TableDescriptor desc)
```
    Description copied from interface: AsyncAdmin
    
    Creates a new table.
    
    Specified by:
    
    createTable in interface AsyncAdmin
    
    Parameters:
    
    desc - table descriptor for table
  - createTable
```
public CompletableFuture<Void> createTable(TableDescriptor desc,
                                           byte[] startKey,
                                           byte[] endKey,
                                           int numRegions)
```
    Description copied from interface: AsyncAdmin
    
    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.
    
    Specified by:
    
    createTable in interface AsyncAdmin
    
    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
```
public CompletableFuture<Void> createTable(TableDescriptor desc,
                                           byte[][] splitKeys)
```
    Description copied from interface: AsyncAdmin
    
    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.
    
    Specified by:
    
    createTable in interface AsyncAdmin
    
    Parameters:
    
    desc - table descriptor for table
    
    splitKeys - array of split keys for the initial regions of the table
  - createTable
```
private CompletableFuture<Void> createTable(TableName tableName,
                                            org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProtos.CreateTableRequest request)
```
  - modifyTable
```
public CompletableFuture<Void> modifyTable(TableDescriptor desc)
```
    Description copied from interface: AsyncAdmin
    
    Modify an existing table, more IRB friendly version.
    
    Specified by:
    
    modifyTable in interface AsyncAdmin
    
    Parameters:
    
    desc - modified description of the table
  - modifyTableStoreFileTracker
```
public CompletableFuture<Void> modifyTableStoreFileTracker(TableName tableName,
                                                           String dstSFT)
```
    Description copied from interface: AsyncAdmin
    
    Change the store file tracker of the given table.
    
    Specified by:
    
    modifyTableStoreFileTracker in interface AsyncAdmin
    
    Parameters:
    
    tableName - the table you want to change
    
    dstSFT - the destination store file tracker
  - deleteTable
```
public CompletableFuture<Void> deleteTable(TableName tableName)
```
    Description copied from interface: AsyncAdmin
    
    Deletes a table.
    
    Specified by:
    
    deleteTable in interface AsyncAdmin
    
    Parameters:
    
    tableName - name of table to delete
  - truncateTable
```
public CompletableFuture<Void> truncateTable(TableName tableName,
                                             boolean preserveSplits)
```
    Description copied from interface: AsyncAdmin
    
    Truncate a table.
    
    Specified by:
    
    truncateTable in interface AsyncAdmin
    
    Parameters:
    
    tableName - name of table to truncate
    
    preserveSplits - True if the splits should be preserved
  - enableTable
```
public CompletableFuture<Void> enableTable(TableName tableName)
```
    Description copied from interface: AsyncAdmin
    
    Enable a table. The table has to be in disabled state for it to be enabled.
    
    Specified by:
    
    enableTable in interface AsyncAdmin
    
    Parameters:
    
    tableName - name of the table
  - disableTable
```
public CompletableFuture<Void> disableTable(TableName tableName)
```
    Description copied from interface: AsyncAdmin
    
    Disable a table. The table has to be in enabled state for it to be disabled. n
    
    Specified by:
    
    disableTable in interface AsyncAdmin
  - completeCheckTableState
```
private static CompletableFuture<Boolean> completeCheckTableState(CompletableFuture<Boolean> future,
                                                                  TableState tableState,
                                                                  Throwable error,
                                                                  TableState.State targetState,
                                                                  TableName tableName)
```
    Utility for completing passed TableState CompletableFuture future using passed parameters. Sets error or boolean result ('true' if table matches the passed-in targetState).
  - isTableEnabled
```
public CompletableFuture<Boolean> isTableEnabled(TableName tableName)
```
    Description copied from interface: AsyncAdmin
    
    Check if a table is enabled.
    
    Specified by:
    
    isTableEnabled in interface AsyncAdmin
    
    Parameters:
    
    tableName - name of table to check
    
    Returns:
    
    true if table is on-line. The return value will be wrapped by a CompletableFuture.
  - isTableDisabled
```
public CompletableFuture<Boolean> isTableDisabled(TableName tableName)
```
    Description copied from interface: AsyncAdmin
    
    Check if a table is disabled.
    
    Specified by:
    
    isTableDisabled in interface AsyncAdmin
    
    Parameters:
    
    tableName - name of table to check
    
    Returns:
    
    true if table is off-line. The return value will be wrapped by a CompletableFuture.
  - isTableAvailable
```
public CompletableFuture<Boolean> isTableAvailable(TableName tableName)
```
    Description copied from interface: AsyncAdmin
    
    Check if a table is available.
    
    Specified by:
    
    isTableAvailable in interface AsyncAdmin
    
    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
```
public CompletableFuture<Boolean> isTableAvailable(TableName tableName,
                                                   byte[][] splitKeys)
```
    Description copied from interface: AsyncAdmin
    
    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.
    
    Specified by:
    
    isTableAvailable in interface AsyncAdmin
    
    Parameters:
    
    tableName - name of table to check
    
    splitKeys - keys to check if the table has been created with all split keys
  - isTableAvailable
```
private CompletableFuture<Boolean> isTableAvailable(TableName tableName,
                                                    Optional<byte[][]> splitKeys)
```
  - compareRegionsWithSplitKeys
```
private boolean compareRegionsWithSplitKeys(List<HRegionLocation> locations,
                                            byte[][] splitKeys)
```
  - addColumnFamily
```
public CompletableFuture<Void> addColumnFamily(TableName tableName,
                                               ColumnFamilyDescriptor columnFamily)
```
    Description copied from interface: AsyncAdmin
    
    Add a column family to an existing table.
    
    Specified by:
    
    addColumnFamily in interface AsyncAdmin
    
    Parameters:
    
    tableName - name of the table to add column family to
    
    columnFamily - column family descriptor of column family to be added
  - deleteColumnFamily
```
public CompletableFuture<Void> deleteColumnFamily(TableName tableName,
                                                  byte[] columnFamily)
```
    Description copied from interface: AsyncAdmin
    
    Delete a column family from a table.
    
    Specified by:
    
    deleteColumnFamily in interface AsyncAdmin
    
    Parameters:
    
    tableName - name of table
    
    columnFamily - name of column family to be deleted
  - modifyColumnFamily
```
public CompletableFuture<Void> modifyColumnFamily(TableName tableName,
                                                  ColumnFamilyDescriptor columnFamily)
```
    Description copied from interface: AsyncAdmin
    
    Modify an existing column family on a table.
    
    Specified by:
    
    modifyColumnFamily in interface AsyncAdmin
    
    Parameters:
    
    tableName - name of table
    
    columnFamily - new column family descriptor to use
  - modifyColumnFamilyStoreFileTracker
```
public CompletableFuture<Void> modifyColumnFamilyStoreFileTracker(TableName tableName,
                                                                  byte[] family,
                                                                  String dstSFT)
```
    Description copied from interface: AsyncAdmin
    
    Change the store file tracker of the given table's given family.
    
    Specified by:
    
    modifyColumnFamilyStoreFileTracker in interface AsyncAdmin
    
    Parameters:
    
    tableName - the table you want to change
    
    family - the family you want to change
    
    dstSFT - the destination store file tracker
  - createNamespace
```
public CompletableFuture<Void> createNamespace(NamespaceDescriptor descriptor)
```
    Description copied from interface: AsyncAdmin
    
    Create a new namespace.
    
    Specified by:
    
    createNamespace in interface AsyncAdmin
    
    Parameters:
    
    descriptor - descriptor which describes the new namespace
  - modifyNamespace
```
public CompletableFuture<Void> modifyNamespace(NamespaceDescriptor descriptor)
```
    Description copied from interface: AsyncAdmin
    
    Modify an existing namespace.
    
    Specified by:
    
    modifyNamespace in interface AsyncAdmin
    
    Parameters:
    
    descriptor - descriptor which describes the new namespace
  - deleteNamespace
```
public CompletableFuture<Void> deleteNamespace(String name)
```
    Description copied from interface: AsyncAdmin
    
    Delete an existing namespace. Only empty namespaces (no tables) can be removed.
    
    Specified by:
    
    deleteNamespace in interface AsyncAdmin
    
    Parameters:
    
    name - namespace name
  - getNamespaceDescriptor
```
public CompletableFuture<NamespaceDescriptor> getNamespaceDescriptor(String name)
```
    Description copied from interface: AsyncAdmin
    
    Get a namespace descriptor by name
    
    Specified by:
    
    getNamespaceDescriptor in interface AsyncAdmin
    
    Parameters:
    
    name - name of namespace descriptor
    
    Returns:
    
    A descriptor wrapped by a CompletableFuture.
  - listNamespaces
```
public CompletableFuture<List<String>> listNamespaces()
```
    Description copied from interface: AsyncAdmin
    
    List available namespaces
    
    Specified by:
    
    listNamespaces in interface AsyncAdmin
    
    Returns:
    
    List of namespaces wrapped by a CompletableFuture.
  - listNamespaceDescriptors
```
public CompletableFuture<List<NamespaceDescriptor>> listNamespaceDescriptors()
```
    Description copied from interface: AsyncAdmin
    
    List available namespace descriptors
    
    Specified by:
    
    listNamespaceDescriptors in interface AsyncAdmin
    
    Returns:
    
    List of descriptors wrapped by a CompletableFuture.
  - getRegions
```
public CompletableFuture<List<RegionInfo>> getRegions(ServerName serverName)
```
    Description copied from interface: AsyncAdmin
    
    Get all the online regions on a region server.
    
    Specified by:
    
    getRegions in interface AsyncAdmin
  - getRegions
```
public CompletableFuture<List<RegionInfo>> getRegions(TableName tableName)
```
    Description copied from interface: AsyncAdmin
    
    Get the regions of a given table.
    
    Specified by:
    
    getRegions in interface AsyncAdmin
  - flush
```
public CompletableFuture<Void> flush(TableName tableName)
```
    Description copied from interface: AsyncAdmin
    
    Flush a table.
    
    Specified by:
    
    flush in interface AsyncAdmin
    
    Parameters:
    
    tableName - table to flush
  - flush
```
public CompletableFuture<Void> flush(TableName tableName,
                                     byte[] columnFamily)
```
    Description copied from interface: AsyncAdmin
    
    Flush the specified column family stores on all regions of the passed table. This runs as a synchronous operation.
    
    Specified by:
    
    flush in interface AsyncAdmin
    
    Parameters:
    
    tableName - table to flush
    
    columnFamily - column family within a table
  - flushRegion
```
public CompletableFuture<Void> flushRegion(byte[] regionName)
```
    Description copied from interface: AsyncAdmin
    
    Flush an individual region.
    
    Specified by:
    
    flushRegion in interface AsyncAdmin
    
    Parameters:
    
    regionName - region to flush
  - flushRegion
```
public CompletableFuture<Void> flushRegion(byte[] regionName,
                                           byte[] columnFamily)
```
    Description copied from interface: AsyncAdmin
    
    Flush a column family within a region.
    
    Specified by:
    
    flushRegion in interface AsyncAdmin
    
    Parameters:
    
    regionName - region to flush
    
    columnFamily - column family within a region. If not present, flush the region's all column families.
  - flush
```
private CompletableFuture<Void> flush(ServerName serverName,
                                      RegionInfo regionInfo,
                                      byte[] columnFamily)
```
  - flushRegionServer
```
public CompletableFuture<Void> flushRegionServer(ServerName sn)
```
    Description copied from interface: AsyncAdmin
    
    Flush all region on the region server.
    
    Specified by:
    
    flushRegionServer in interface AsyncAdmin
    
    Parameters:
    
    sn - server to flush
  - compact
```
public CompletableFuture<Void> compact(TableName tableName,
                                       CompactType compactType)
```
    Description copied from interface: AsyncAdmin
    
    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.
    
    Specified by:
    
    compact in interface AsyncAdmin
    
    Parameters:
    
    tableName - table to compact
    
    compactType - CompactType
  - compact
```
public CompletableFuture<Void> compact(TableName tableName,
                                       byte[] columnFamily,
                                       CompactType compactType)
```
    Description copied from interface: AsyncAdmin
    
    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.
    
    Specified by:
    
    compact in interface AsyncAdmin
    
    Parameters:
    
    tableName - table to compact
    
    columnFamily - column family within a table
    
    compactType - CompactType
  - compactRegion
```
public CompletableFuture<Void> compactRegion(byte[] regionName)
```
    Description copied from interface: AsyncAdmin
    
    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.
    
    Specified by:
    
    compactRegion in interface AsyncAdmin
    
    Parameters:
    
    regionName - region to compact
  - compactRegion
```
public CompletableFuture<Void> compactRegion(byte[] regionName,
                                             byte[] columnFamily)
```
    Description copied from interface: AsyncAdmin
    
    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.
    
    Specified by:
    
    compactRegion in interface AsyncAdmin
    
    Parameters:
    
    regionName - region to compact
    
    columnFamily - column family within a region. If not present, compact the region's all column families.
  - majorCompact
```
public CompletableFuture<Void> majorCompact(TableName tableName,
                                            CompactType compactType)
```
    Description copied from interface: AsyncAdmin
    
    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.
    
    Specified by:
    
    majorCompact in interface AsyncAdmin
    
    Parameters:
    
    tableName - table to major compact
    
    compactType - CompactType
  - majorCompact
```
public CompletableFuture<Void> majorCompact(TableName tableName,
                                            byte[] columnFamily,
                                            CompactType compactType)
```
    Description copied from interface: AsyncAdmin
    
    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.
    
    Specified by:
    
    majorCompact in interface AsyncAdmin
    
    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
```
public CompletableFuture<Void> majorCompactRegion(byte[] regionName)
```
    Description copied from interface: AsyncAdmin
    
    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.
    
    Specified by:
    
    majorCompactRegion in interface AsyncAdmin
    
    Parameters:
    
    regionName - region to major compact
  - majorCompactRegion
```
public CompletableFuture<Void> majorCompactRegion(byte[] regionName,
                                                  byte[] columnFamily)
```
    Description copied from interface: AsyncAdmin
    
    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.
    
    Specified by:
    
    majorCompactRegion in interface AsyncAdmin
    
    Parameters:
    
    regionName - region to major compact
    
    columnFamily - column family within a region. If not present, major compact the region's all column families.
  - compactRegionServer
```
public CompletableFuture<Void> compactRegionServer(ServerName sn)
```
    Description copied from interface: AsyncAdmin
    
    Compact all regions on the region server.
    
    Specified by:
    
    compactRegionServer in interface AsyncAdmin
    
    Parameters:
    
    sn - the region server name
  - majorCompactRegionServer
```
public CompletableFuture<Void> majorCompactRegionServer(ServerName sn)
```
    Description copied from interface: AsyncAdmin
    
    Compact all regions on the region server.
    
    Specified by:
    
    majorCompactRegionServer in interface AsyncAdmin
    
    Parameters:
    
    sn - the region server name
  - compactRegionServer
```
private CompletableFuture<Void> compactRegionServer(ServerName sn,
                                                    boolean major)
```
  - compactRegion
```
private CompletableFuture<Void> compactRegion(byte[] regionName,
                                              byte[] columnFamily,
                                              boolean major)
```
  - getTableHRegionLocations
```
private CompletableFuture<List<HRegionLocation>> getTableHRegionLocations(TableName tableName)
```
    List all region locations for the specific table.
  - compact
```
private CompletableFuture<Void> compact(TableName tableName,
                                        byte[] columnFamily,
                                        boolean major,
                                        CompactType compactType)
```
    Compact column family of a table, Asynchronous operation even if CompletableFuture.get()
  - compact
```
private CompletableFuture<Void> compact(ServerName sn,
                                        RegionInfo hri,
                                        boolean major,
                                        byte[] columnFamily)
```
    Compact the region at specific region server.
  - toEncodeRegionName
```
private byte[] toEncodeRegionName(byte[] regionName)
```
  - checkAndGetTableName
```
private void checkAndGetTableName(byte[] encodeRegionName,
                                  AtomicReference<TableName> tableName,
                                  CompletableFuture<TableName> result)
```
  - checkRegionsAndGetTableName
```
private CompletableFuture<TableName> checkRegionsAndGetTableName(byte[][] encodedRegionNames)
```
  - mergeSwitch
```
public CompletableFuture<Boolean> mergeSwitch(boolean enabled,
                                              boolean drainMerges)
```
    Description copied from interface: AsyncAdmin
    
    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.
    
    Specified by:
    
    mergeSwitch in interface AsyncAdmin
    
    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
```
public CompletableFuture<Boolean> isMergeEnabled()
```
    Description copied from interface: AsyncAdmin
    
    Query the current state of the Merge switch.
    
    Specified by:
    
    isMergeEnabled in interface AsyncAdmin
    
    Returns:
    
    true if the switch is on, false otherwise. The return value will be wrapped by a CompletableFuture
  - splitSwitch
```
public CompletableFuture<Boolean> splitSwitch(boolean enabled,
                                              boolean drainSplits)
```
    Description copied from interface: AsyncAdmin
    
    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.
    
    Specified by:
    
    splitSwitch in interface AsyncAdmin
    
    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
```
public CompletableFuture<Boolean> isSplitEnabled()
```
    Description copied from interface: AsyncAdmin
    
    Query the current state of the Split switch.
    
    Specified by:
    
    isSplitEnabled in interface AsyncAdmin
    
    Returns:
    
    true if the switch is on, false otherwise. The return value will be wrapped by a CompletableFuture
  - setSplitOrMergeOn
```
private CompletableFuture<Boolean> setSplitOrMergeOn(boolean enabled,
                                                     boolean synchronous,
                                                     MasterSwitchType switchType)
```
  - isSplitOrMergeOn
```
private CompletableFuture<Boolean> isSplitOrMergeOn(MasterSwitchType switchType)
```
  - mergeRegions
```
public CompletableFuture<Void> mergeRegions(List<byte[]> nameOfRegionsToMerge,
                                            boolean forcible)
```
    Description copied from interface: AsyncAdmin
    
    Merge multiple regions (>=2).
    
    Specified by:
    
    mergeRegions in interface AsyncAdmin
    
    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
```
public CompletableFuture<Void> split(TableName tableName)
```
    Description copied from interface: AsyncAdmin
    
    Split a table. The method will execute split action for each region in table.
    
    Specified by:
    
    split in interface AsyncAdmin
    
    Parameters:
    
    tableName - table to split
  - split
```
public CompletableFuture<Void> split(TableName tableName,
                                     byte[] splitPoint)
```
    Description copied from interface: AsyncAdmin
    
    Split a table.
    
    Specified by:
    
    split in interface AsyncAdmin
    
    Parameters:
    
    tableName - table to split
    
    splitPoint - the explicit position to split on
  - splitRegion
```
public CompletableFuture<Void> splitRegion(byte[] regionName)
```
    Description copied from interface: AsyncAdmin
    
    Split an individual region.
    
    Specified by:
    
    splitRegion in interface AsyncAdmin
    
    Parameters:
    
    regionName - region to split
  - splitRegion
```
public CompletableFuture<Void> splitRegion(byte[] regionName,
                                           byte[] splitPoint)
```
    Description copied from interface: AsyncAdmin
    
    Split an individual region.
    
    Specified by:
    
    splitRegion in interface AsyncAdmin
    
    Parameters:
    
    regionName - region to split
    
    splitPoint - the explicit position to split on. If not present, it will decide by region server.
  - split
```
private CompletableFuture<Void> split(RegionInfo hri,
                                      byte[] splitPoint)
```
  - assign
```
public CompletableFuture<Void> assign(byte[] regionName)
```
    Description copied from interface: AsyncAdmin
    
    Assign an individual region.
    
    Specified by:
    
    assign in interface AsyncAdmin
    
    Parameters:
    
    regionName - Encoded or full name of region to assign.
  - unassign
```
public CompletableFuture<Void> unassign(byte[] regionName)
```
    Description copied from interface: AsyncAdmin
    
    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 AsyncAdmin.move(byte[], ServerName) if you want to control the region movement.
    
    Specified by:
    
    unassign in interface AsyncAdmin
    
    Parameters:
    
    regionName - Encoded or full name of region to unassign.
  - offline
```
public CompletableFuture<Void> offline(byte[] regionName)
```
    Description copied from interface: AsyncAdmin
    
    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 AsyncAdmin
    
    Parameters:
    
    regionName - Encoded or full name of region to offline
  - move
```
public CompletableFuture<Void> move(byte[] regionName)
```
    Description copied from interface: AsyncAdmin
    
    Move the region r to a random server.
    
    Specified by:
    
    move in interface AsyncAdmin
    
    Parameters:
    
    regionName - Encoded or full name of region to move.
  - move
```
public CompletableFuture<Void> move(byte[] regionName,
                                    ServerName destServerName)
```
    Description copied from interface: AsyncAdmin
    
    Move the region r to dest.
    
    Specified by:
    
    move in interface AsyncAdmin
    
    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
  - moveRegion
```
private CompletableFuture<Void> moveRegion(RegionInfo regionInfo,
                                           org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProtos.MoveRegionRequest request)
```
  - setQuota
```
public CompletableFuture<Void> setQuota(QuotaSettings quota)
```
    Description copied from interface: AsyncAdmin
    
    Apply the new quota settings.
    
    Specified by:
    
    setQuota in interface AsyncAdmin
    
    Parameters:
    
    quota - the quota settings
  - getQuota
```
public CompletableFuture<List<QuotaSettings>> getQuota(QuotaFilter filter)
```
    Description copied from interface: AsyncAdmin
    
    List the quotas based on the filter.
    
    Specified by:
    
    getQuota in interface AsyncAdmin
    
    Parameters:
    
    filter - the quota settings filter
    
    Returns:
    
    the QuotaSetting list, which wrapped by a CompletableFuture.
  - addReplicationPeer
```
public CompletableFuture<Void> addReplicationPeer(String peerId,
                                                  ReplicationPeerConfig peerConfig,
                                                  boolean enabled)
```
    Description copied from interface: AsyncAdmin
    
    Add a new replication peer for replicating data to slave cluster
    
    Specified by:
    
    addReplicationPeer in interface AsyncAdmin
    
    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
```
public CompletableFuture<Void> removeReplicationPeer(String peerId)
```
    Description copied from interface: AsyncAdmin
    
    Remove a peer and stop the replication
    
    Specified by:
    
    removeReplicationPeer in interface AsyncAdmin
    
    Parameters:
    
    peerId - a short name that identifies the peer
  - enableReplicationPeer
```
public CompletableFuture<Void> enableReplicationPeer(String peerId)
```
    Description copied from interface: AsyncAdmin
    
    Restart the replication stream to the specified peer
    
    Specified by:
    
    enableReplicationPeer in interface AsyncAdmin
    
    Parameters:
    
    peerId - a short name that identifies the peer
  - disableReplicationPeer
```
public CompletableFuture<Void> disableReplicationPeer(String peerId)
```
    Description copied from interface: AsyncAdmin
    
    Stop the replication stream to the specified peer
    
    Specified by:
    
    disableReplicationPeer in interface AsyncAdmin
    
    Parameters:
    
    peerId - a short name that identifies the peer
  - getReplicationPeerConfig
```
public CompletableFuture<ReplicationPeerConfig> getReplicationPeerConfig(String peerId)
```
    Description copied from interface: AsyncAdmin
    
    Returns the configured ReplicationPeerConfig for the specified peer
    
    Specified by:
    
    getReplicationPeerConfig in interface AsyncAdmin
    
    Parameters:
    
    peerId - a short name that identifies the peer
    
    Returns:
    
    ReplicationPeerConfig for the peer wrapped by a CompletableFuture.
  - updateReplicationPeerConfig
```
public CompletableFuture<Void> updateReplicationPeerConfig(String peerId,
                                                           ReplicationPeerConfig peerConfig)
```
    Description copied from interface: AsyncAdmin
    
    Update the peerConfig for the specified peer
    
    Specified by:
    
    updateReplicationPeerConfig in interface AsyncAdmin
    
    Parameters:
    
    peerId - a short name that identifies the peer
    
    peerConfig - new config for the peer
  - appendReplicationPeerTableCFs
```
public CompletableFuture<Void> appendReplicationPeerTableCFs(String id,
                                                             Map<TableName,List<String>> tableCfs)
```
    Description copied from interface: AsyncAdmin
    
    Append the replicable table-cf config of the specified peer
    
    Specified by:
    
    appendReplicationPeerTableCFs in interface AsyncAdmin
    
    Parameters:
    
    id - a short that identifies the cluster
    
    tableCfs - A map from tableName to column family names
  - removeReplicationPeerTableCFs
```
public CompletableFuture<Void> removeReplicationPeerTableCFs(String id,
                                                             Map<TableName,List<String>> tableCfs)
```
    Description copied from interface: AsyncAdmin
    
    Remove some table-cfs from config of the specified peer
    
    Specified by:
    
    removeReplicationPeerTableCFs in interface AsyncAdmin
    
    Parameters:
    
    id - a short name that identifies the cluster
    
    tableCfs - A map from tableName to column family names
  - listReplicationPeers
```
public CompletableFuture<List<ReplicationPeerDescription>> listReplicationPeers()
```
    Description copied from interface: AsyncAdmin
    
    Return a list of replication peers.
    
    Specified by:
    
    listReplicationPeers in interface AsyncAdmin
    
    Returns:
    
    a list of replication peers description. The return value will be wrapped by a CompletableFuture.
  - listReplicationPeers
```
public CompletableFuture<List<ReplicationPeerDescription>> listReplicationPeers(Pattern pattern)
```
    Description copied from interface: AsyncAdmin
    
    Return a list of replication peers.
    
    Specified by:
    
    listReplicationPeers in interface AsyncAdmin
    
    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.
  - listReplicationPeers
```
private CompletableFuture<List<ReplicationPeerDescription>> listReplicationPeers(org.apache.hadoop.hbase.shaded.protobuf.generated.ReplicationProtos.ListReplicationPeersRequest request)
```
  - listReplicatedTableCFs
```
public CompletableFuture<List<TableCFs>> listReplicatedTableCFs()
```
    Description copied from interface: AsyncAdmin
    
    Find all table and column families that are replicated from this cluster
    
    Specified by:
    
    listReplicatedTableCFs in interface AsyncAdmin
    
    Returns:
    
    the replicated table-cfs list of this cluster. The return value will be wrapped by a CompletableFuture.
  - snapshot
```
public CompletableFuture<Void> snapshot(SnapshotDescription snapshotDesc)
```
    Description copied from interface: AsyncAdmin
    
    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 AsyncAdmin.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 AsyncAdmin
    
    Parameters:
    
    snapshotDesc - snapshot to take
  - isSnapshotFinished
```
public CompletableFuture<Boolean> isSnapshotFinished(SnapshotDescription snapshot)
```
    Description copied from interface: AsyncAdmin
    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 AsyncAdmin
    
    Parameters:
    
    snapshot - description of the snapshot to check
    
    Returns:
    
    true if the snapshot is completed, false if the snapshot is still running
  - restoreSnapshot
```
public CompletableFuture<Void> restoreSnapshot(String snapshotName)
```
    Description copied from interface: AsyncAdmin
    
    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 AsyncAdmin
    
    Parameters:
    
    snapshotName - name of the snapshot to restore
  - restoreSnapshot
```
public CompletableFuture<Void> restoreSnapshot(String snapshotName,
                                               boolean takeFailSafeSnapshot,
                                               boolean restoreAcl)
```
    Description copied from interface: AsyncAdmin
    
    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 AsyncAdmin
    
    Parameters:
    
    snapshotName - name of the snapshot to restore
    
    takeFailSafeSnapshot - true if the failsafe snapshot should be taken
    
    restoreAcl - true to restore acl of snapshot
  - restoreSnapshot
```
private CompletableFuture<Void> restoreSnapshot(String snapshotName,
                                                TableName tableName,
                                                boolean takeFailSafeSnapshot,
                                                boolean restoreAcl)
```
  - completeConditionalOnFuture
```
private <T> void completeConditionalOnFuture(CompletableFuture<T> dependentFuture,
                                             CompletableFuture<T> parentFuture)
```
  - cloneSnapshot
```
public CompletableFuture<Void> cloneSnapshot(String snapshotName,
                                             TableName tableName,
                                             boolean restoreAcl,
                                             String customSFT)
```
    Description copied from interface: AsyncAdmin
    
    Create a new table by cloning the snapshot content.
    
    Specified by:
    
    cloneSnapshot in interface AsyncAdmin
    
    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
    
    customSFT - specify the StroreFileTracker used for the table
  - internalRestoreSnapshot
```
private CompletableFuture<Void> internalRestoreSnapshot(String snapshotName,
                                                        TableName tableName,
                                                        boolean restoreAcl,
                                                        String customSFT)
```
  - listSnapshots
```
public CompletableFuture<List<SnapshotDescription>> listSnapshots()
```
    Description copied from interface: AsyncAdmin
    
    List completed snapshots.
    
    Specified by:
    
    listSnapshots in interface AsyncAdmin
    
    Returns:
    
    a list of snapshot descriptors for completed snapshots wrapped by a CompletableFuture
  - listSnapshots
```
public CompletableFuture<List<SnapshotDescription>> listSnapshots(Pattern pattern)
```
    Description copied from interface: AsyncAdmin
    
    List all the completed snapshots matching the given pattern.
    
    Specified by:
    
    listSnapshots in interface AsyncAdmin
    
    Parameters:
    
    pattern - The compiled regular expression to match against
    
    Returns:
    
    - returns a List of SnapshotDescription wrapped by a CompletableFuture
  - getCompletedSnapshots
```
private CompletableFuture<List<SnapshotDescription>> getCompletedSnapshots(Pattern pattern)
```
  - listTableSnapshots
```
public CompletableFuture<List<SnapshotDescription>> listTableSnapshots(Pattern tableNamePattern)
```
    Description copied from interface: AsyncAdmin
    
    List all the completed snapshots matching the given table name pattern.
    
    Specified by:
    
    listTableSnapshots in interface AsyncAdmin
    
    Parameters:
    
    tableNamePattern - The compiled table name regular expression to match against
    
    Returns:
    
    - returns a List of completed SnapshotDescription wrapped by a CompletableFuture
  - listTableSnapshots
```
public CompletableFuture<List<SnapshotDescription>> listTableSnapshots(Pattern tableNamePattern,
                                                                       Pattern snapshotNamePattern)
```
    Description copied from interface: AsyncAdmin
    
    List all the completed snapshots matching the given table name regular expression and snapshot name regular expression.
    
    Specified by:
    
    listTableSnapshots in interface AsyncAdmin
    
    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
  - getCompletedSnapshots
```
private CompletableFuture<List<SnapshotDescription>> getCompletedSnapshots(Pattern tableNamePattern,
                                                                           Pattern snapshotNamePattern)
```
  - deleteSnapshot
```
public CompletableFuture<Void> deleteSnapshot(String snapshotName)
```
    Description copied from interface: AsyncAdmin
    
    Delete an existing snapshot.
    
    Specified by:
    
    deleteSnapshot in interface AsyncAdmin
    
    Parameters:
    
    snapshotName - name of the snapshot
  - deleteSnapshots
```
public CompletableFuture<Void> deleteSnapshots()
```
    Description copied from interface: AsyncAdmin
    
    Delete all existing snapshots.
    
    Specified by:
    
    deleteSnapshots in interface AsyncAdmin
  - deleteSnapshots
```
public CompletableFuture<Void> deleteSnapshots(Pattern snapshotNamePattern)
```
    Description copied from interface: AsyncAdmin
    
    Delete existing snapshots whose names match the pattern passed.
    
    Specified by:
    
    deleteSnapshots in interface AsyncAdmin
    
    Parameters:
    
    snapshotNamePattern - pattern for names of the snapshot to match
  - deleteTableSnapshots
```
public CompletableFuture<Void> deleteTableSnapshots(Pattern tableNamePattern)
```
    Description copied from interface: AsyncAdmin
    
    Delete all existing snapshots matching the given table name pattern.
    
    Specified by:
    
    deleteTableSnapshots in interface AsyncAdmin
    
    Parameters:
    
    tableNamePattern - The compiled table name regular expression to match against
  - deleteTableSnapshots
```
public CompletableFuture<Void> deleteTableSnapshots(Pattern tableNamePattern,
                                                    Pattern snapshotNamePattern)
```
    Description copied from interface: AsyncAdmin
    
    Delete all existing snapshots matching the given table name regular expression and snapshot name regular expression.
    
    Specified by:
    
    deleteTableSnapshots in interface AsyncAdmin
    
    Parameters:
    
    tableNamePattern - The compiled table name regular expression to match against
    
    snapshotNamePattern - The compiled snapshot name regular expression to match against
  - internalDeleteSnapshots
```
private CompletableFuture<Void> internalDeleteSnapshots(Pattern tableNamePattern,
                                                        Pattern snapshotNamePattern)
```
  - internalDeleteSnapshot
```
private CompletableFuture<Void> internalDeleteSnapshot(SnapshotDescription snapshot)
```
  - execProcedure
```
public CompletableFuture<Void> execProcedure(String signature,
                                             String instance,
                                             Map<String,String> props)
```
    Description copied from interface: AsyncAdmin
    
    Execute a distributed procedure on a cluster.
    
    Specified by:
    
    execProcedure in interface AsyncAdmin
    
    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
```
public CompletableFuture<byte[]> execProcedureWithReturn(String signature,
                                                         String instance,
                                                         Map<String,String> props)
```
    Description copied from interface: AsyncAdmin
    
    Execute a distributed procedure on a cluster.
    
    Specified by:
    
    execProcedureWithReturn in interface AsyncAdmin
    
    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
```
public CompletableFuture<Boolean> isProcedureFinished(String signature,
                                                      String instance,
                                                      Map<String,String> props)
```
    Description copied from interface: AsyncAdmin
    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 AsyncAdmin
    
    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
```
public CompletableFuture<Boolean> abortProcedure(long procId,
                                                 boolean mayInterruptIfRunning)
```
    Description copied from interface: AsyncAdmin
    
    Abort a procedure Do not use. Usually it is ignored but if not, it can do more damage than good. See hbck2.
    
    Specified by:
    
    abortProcedure in interface AsyncAdmin
    
    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
```
public CompletableFuture<String> getProcedures()
```
    Description copied from interface: AsyncAdmin
    
    List procedures
    
    Specified by:
    
    getProcedures in interface AsyncAdmin
    
    Returns:
    
    procedure list JSON wrapped by CompletableFuture
  - getLocks
```
public CompletableFuture<String> getLocks()
```
    Description copied from interface: AsyncAdmin
    
    List locks.
    
    Specified by:
    
    getLocks in interface AsyncAdmin
    
    Returns:
    
    lock list JSON wrapped by CompletableFuture
  - decommissionRegionServers
```
public CompletableFuture<Void> decommissionRegionServers(List<ServerName> servers,
                                                         boolean offload)
```
    Description copied from interface: AsyncAdmin
    
    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 AsyncAdmin
    
    Parameters:
    
    servers - The list of servers to decommission.
    
    offload - True to offload the regions from the decommissioned servers
  - listDecommissionedRegionServers
```
public CompletableFuture<List<ServerName>> listDecommissionedRegionServers()
```
    Description copied from interface: AsyncAdmin
    
    List region servers marked as decommissioned, which can not be assigned regions.
    
    Specified by:
    
    listDecommissionedRegionServers in interface AsyncAdmin
    
    Returns:
    
    List of decommissioned region servers wrapped by CompletableFuture
  - recommissionRegionServer
```
public CompletableFuture<Void> recommissionRegionServer(ServerName server,
                                                        List<byte[]> encodedRegionNames)
```
    Description copied from interface: AsyncAdmin
    
    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 AsyncAdmin
    
    Parameters:
    
    server - The server to recommission.
    
    encodedRegionNames - Regions to load onto the server.
  - getRegionLocation
```
CompletableFuture<HRegionLocation> getRegionLocation(byte[] regionNameOrEncodedRegionName)
```
    Get the region location for the passed region name. The region name may be a full region name or encoded region name. If the region does not found, then it'll throw an UnknownRegionException wrapped by a CompletableFuture
    
    Parameters:
    
    regionNameOrEncodedRegionName - region name or encoded region name
    
    Returns:
    
    region location, wrapped by a CompletableFuture
  - getRegionInfo
```
private CompletableFuture<RegionInfo> getRegionInfo(byte[] regionNameOrEncodedRegionName)
```
    Get the region info for the passed region name. The region name may be a full region name or encoded region name. If the region does not found, then it'll throw an UnknownRegionException wrapped by a CompletableFuture
    
    Returns:
    
    region info, wrapped by a CompletableFuture
  - getSplitKeys
```
private byte[][] getSplitKeys(byte[] startKey,
                              byte[] endKey,
                              int numRegions)
```
  - verifySplitKeys
```
private void verifySplitKeys(byte[][] splitKeys)
```
  - waitProcedureResult
```
private CompletableFuture<Void> waitProcedureResult(CompletableFuture<Long> procFuture)
```
  - getProcedureResult
```
private void getProcedureResult(long procId,
                                CompletableFuture<Void> future,
                                int retries)
```
  - failedFuture
```
private <T> CompletableFuture<T> failedFuture(Throwable error)
```
  - completeExceptionally
```
private <T> boolean completeExceptionally(CompletableFuture<T> future,
                                          Throwable error)
```
  - getClusterMetrics
```
public CompletableFuture<ClusterMetrics> getClusterMetrics()
```
    Description copied from interface: AsyncAdmin
    
    Returns cluster status wrapped by CompletableFuture
    
    Specified by:
    
    getClusterMetrics in interface AsyncAdmin
  - getClusterMetrics
```
public CompletableFuture<ClusterMetrics> getClusterMetrics(EnumSet<ClusterMetrics.Option> options)
```
    Description copied from interface: AsyncAdmin
    
    Returns cluster status wrapped by CompletableFuture
    
    Specified by:
    
    getClusterMetrics in interface AsyncAdmin
  - shutdown
```
public CompletableFuture<Void> shutdown()
```
    Description copied from interface: AsyncAdmin
    
    Shuts down the HBase cluster.
    
    Specified by:
    
    shutdown in interface AsyncAdmin
  - stopMaster
```
public CompletableFuture<Void> stopMaster()
```
    Description copied from interface: AsyncAdmin
    
    Shuts down the current HBase master only.
    
    Specified by:
    
    stopMaster in interface AsyncAdmin
  - stopRegionServer
```
public CompletableFuture<Void> stopRegionServer(ServerName serverName)
```
    Description copied from interface: AsyncAdmin
    
    Stop the designated regionserver. n
    
    Specified by:
    
    stopRegionServer in interface AsyncAdmin
  - updateConfiguration
```
public CompletableFuture<Void> updateConfiguration(ServerName serverName)
```
    Description copied from interface: AsyncAdmin
    
    Update the configuration and trigger an online config change on the regionserver.
    
    Specified by:
    
    updateConfiguration in interface AsyncAdmin
    
    Parameters:
    
    serverName - : The server whose config needs to be updated.
  - updateConfiguration
```
public CompletableFuture<Void> updateConfiguration()
```
    Description copied from interface: AsyncAdmin
    
    Update the configuration and trigger an online config change on all the masters and regionservers.
    
    Specified by:
    
    updateConfiguration in interface AsyncAdmin
  - rollWALWriter
```
public CompletableFuture<Void> rollWALWriter(ServerName serverName)
```
    Description copied from interface: AsyncAdmin
    
    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.
    
    Specified by:
    
    rollWALWriter in interface AsyncAdmin
    
    Parameters:
    
    serverName - The servername of the region server.
  - clearCompactionQueues
```
public CompletableFuture<Void> clearCompactionQueues(ServerName serverName,
                                                     Set<String> queues)
```
    Description copied from interface: AsyncAdmin
    
    Clear compacting queues on a region server.
    
    Specified by:
    
    clearCompactionQueues in interface AsyncAdmin
    
    Parameters:
    
    serverName - The servername of the region server.
    
    queues - the set of queue name
  - getSecurityCapabilities
```
public CompletableFuture<List<SecurityCapability>> getSecurityCapabilities()
```
    Description copied from interface: AsyncAdmin
    
    Returns the list of supported security capabilities. The return value will be wrapped by a CompletableFuture.
    
    Specified by:
    
    getSecurityCapabilities in interface AsyncAdmin
  - getRegionMetrics
```
public CompletableFuture<List<RegionMetrics>> getRegionMetrics(ServerName serverName)
```
    Description copied from interface: AsyncAdmin
    
    Get a list of RegionMetrics of all regions hosted on a region server.
    
    Specified by:
    
    getRegionMetrics in interface AsyncAdmin
    
    Returns:
    
    list of RegionMetrics wrapped by CompletableFuture
  - getRegionMetrics
```
public CompletableFuture<List<RegionMetrics>> getRegionMetrics(ServerName serverName,
                                                               TableName tableName)
```
    Description copied from interface: AsyncAdmin
    
    Get a list of RegionMetrics of all regions hosted on a region server for a table.
    
    Specified by:
    
    getRegionMetrics in interface AsyncAdmin
    
    Returns:
    
    a list of RegionMetrics wrapped by CompletableFuture
  - getRegionMetrics
```
private CompletableFuture<List<RegionMetrics>> getRegionMetrics(org.apache.hadoop.hbase.shaded.protobuf.generated.AdminProtos.GetRegionLoadRequest request,
                                                                ServerName serverName)
```
  - isMasterInMaintenanceMode
```
public CompletableFuture<Boolean> isMasterInMaintenanceMode()
```
    Description copied from interface: AsyncAdmin
    
    Check whether master is in maintenance mode
    
    Specified by:
    
    isMasterInMaintenanceMode in interface AsyncAdmin
    
    Returns:
    
    true if master is in maintenance mode, false otherwise. The return value will be wrapped by a CompletableFuture
  - getCompactionState
```
public CompletableFuture<CompactionState> getCompactionState(TableName tableName,
                                                             CompactType compactType)
```
    Description copied from interface: AsyncAdmin
    
    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 AsyncAdmin
    
    Parameters:
    
    tableName - table to examine
    
    compactType - CompactType
    
    Returns:
    
    the current compaction state wrapped by a CompletableFuture
  - getCompactionStateForRegion
```
public CompletableFuture<CompactionState> getCompactionStateForRegion(byte[] regionName)
```
    Description copied from interface: AsyncAdmin
    
    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 AsyncAdmin
    
    Parameters:
    
    regionName - region to examine
    
    Returns:
    
    the current compaction state wrapped by a CompletableFuture
  - getLastMajorCompactionTimestamp
```
public CompletableFuture<Optional<Long>> getLastMajorCompactionTimestamp(TableName tableName)
```
    Description copied from interface: AsyncAdmin
    
    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.
    
    Specified by:
    
    getLastMajorCompactionTimestamp in interface AsyncAdmin
    
    Parameters:
    
    tableName - table to examine
    
    Returns:
    
    the last major compaction timestamp wrapped by a CompletableFuture
  - getLastMajorCompactionTimestampForRegion
```
public CompletableFuture<Optional<Long>> getLastMajorCompactionTimestampForRegion(byte[] regionName)
```
    Description copied from interface: AsyncAdmin
    
    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.
    
    Specified by:
    
    getLastMajorCompactionTimestampForRegion in interface AsyncAdmin
    
    Parameters:
    
    regionName - region to examine
    
    Returns:
    
    the last major compaction timestamp wrapped by a CompletableFuture
  - compactionSwitch
```
public CompletableFuture<Map<ServerName,Boolean>> compactionSwitch(boolean switchState,
                                                                   List<String> serverNamesList)
```
    Description copied from interface: AsyncAdmin
    
    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 AsyncAdmin
    
    Parameters:
    
    switchState - Set to true to enable, false to disable.
    
    serverNamesList - list of region servers.
    
    Returns:
    
    Previous compaction states for region servers
  - getRegionServerList
```
private CompletableFuture<List<ServerName>> getRegionServerList(List<String> serverNamesList)
```
  - switchCompact
```
private CompletableFuture<Boolean> switchCompact(ServerName serverName,
                                                 boolean onOrOff)
```
  - balancerSwitch
```
public CompletableFuture<Boolean> balancerSwitch(boolean on,
                                                 boolean drainRITs)
```
    Description copied from interface: AsyncAdmin
    
    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.
    
    Specified by:
    
    balancerSwitch in interface AsyncAdmin
    
    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
```
public CompletableFuture<BalanceResponse> balance(BalanceRequest request)
```
    Description copied from interface: AsyncAdmin
    
    Invoke the balancer with the given balance request. The BalanceRequest defines how the balancer will run. See BalanceRequest for more details.
    
    Specified by:
    
    balance in interface AsyncAdmin
    
    Parameters:
    
    request - defines how the balancer should run
    
    Returns:
    
    BalanceResponse with details about the results of the invocation.
  - isBalancerEnabled
```
public CompletableFuture<Boolean> isBalancerEnabled()
```
    Description copied from interface: AsyncAdmin
    
    Query the current state of the balancer.
    
    Specified by:
    
    isBalancerEnabled in interface AsyncAdmin
    
    Returns:
    
    true if the balance switch is on, false otherwise. The return value will be wrapped by a CompletableFuture.
  - normalizerSwitch
```
public CompletableFuture<Boolean> normalizerSwitch(boolean on)
```
    Description copied from interface: AsyncAdmin
    
    Set region normalizer on/off.
    
    Specified by:
    
    normalizerSwitch in interface AsyncAdmin
    
    Parameters:
    
    on - whether normalizer should be on or off
    
    Returns:
    
    Previous normalizer value wrapped by a CompletableFuture
  - isNormalizerEnabled
```
public CompletableFuture<Boolean> isNormalizerEnabled()
```
    Description copied from interface: AsyncAdmin
    
    Query the current state of the region normalizer
    
    Specified by:
    
    isNormalizerEnabled in interface AsyncAdmin
    
    Returns:
    
    true if region normalizer is on, false otherwise. The return value will be wrapped by a CompletableFuture
  - normalize
```
public CompletableFuture<Boolean> normalize(NormalizeTableFilterParams ntfp)
```
    Description copied from interface: AsyncAdmin
    
    Invoke region normalizer. Can NOT run for various reasons. Check logs.
    
    Specified by:
    
    normalize in interface AsyncAdmin
    
    Parameters:
    
    ntfp - limit to tables matching the specified filter.
    
    Returns:
    
    true if region normalizer ran, false otherwise. The return value will be wrapped by a CompletableFuture
  - normalize
```
private CompletableFuture<Boolean> normalize(org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProtos.NormalizeRequest request)
```
  - cleanerChoreSwitch
```
public CompletableFuture<Boolean> cleanerChoreSwitch(boolean enabled)
```
    Description copied from interface: AsyncAdmin
    
    Turn the cleaner chore on/off. n * @return Previous cleaner state wrapped by a CompletableFuture
    
    Specified by:
    
    cleanerChoreSwitch in interface AsyncAdmin
  - isCleanerChoreEnabled
```
public CompletableFuture<Boolean> isCleanerChoreEnabled()
```
    Description copied from interface: AsyncAdmin
    
    Query the current state of the cleaner chore.
    
    Specified by:
    
    isCleanerChoreEnabled in interface AsyncAdmin
    
    Returns:
    
    true if cleaner chore is on, false otherwise. The return value will be wrapped by a CompletableFuture
  - runCleanerChore
```
public CompletableFuture<Boolean> runCleanerChore()
```
    Description copied from interface: AsyncAdmin
    
    Ask for cleaner chore to run.
    
    Specified by:
    
    runCleanerChore in interface AsyncAdmin
    
    Returns:
    
    true if cleaner chore ran, false otherwise. The return value will be wrapped by a CompletableFuture
  - catalogJanitorSwitch
```
public CompletableFuture<Boolean> catalogJanitorSwitch(boolean enabled)
```
    Description copied from interface: AsyncAdmin
    
    Turn the catalog janitor on/off. n * @return the previous state wrapped by a CompletableFuture
    
    Specified by:
    
    catalogJanitorSwitch in interface AsyncAdmin
  - isCatalogJanitorEnabled
```
public CompletableFuture<Boolean> isCatalogJanitorEnabled()
```
    Description copied from interface: AsyncAdmin
    
    Query on the catalog janitor state.
    
    Specified by:
    
    isCatalogJanitorEnabled in interface AsyncAdmin
    
    Returns:
    
    true if the catalog janitor is on, false otherwise. The return value will be wrapped by a CompletableFuture
  - runCatalogJanitor
```
public CompletableFuture<Integer> runCatalogJanitor()
```
    Description copied from interface: AsyncAdmin
    
    Ask for a scan of the catalog table.
    
    Specified by:
    
    runCatalogJanitor in interface AsyncAdmin
    
    Returns:
    
    the number of entries cleaned. The return value will be wrapped by a CompletableFuture
  - coprocessorService
```
public <S,R> CompletableFuture<R> coprocessorService(Function<com.google.protobuf.RpcChannel,S> stubMaker,
                                                     ServiceCaller<S,R> callable)
```
    Description copied from interface: AsyncAdmin
    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)
 
```
    Specified by:
    
    coprocessorService in interface AsyncAdmin
    
    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
```
public <S,R> CompletableFuture<R> coprocessorService(Function<com.google.protobuf.RpcChannel,S> stubMaker,
                                                     ServiceCaller<S,R> callable,
                                                     ServerName serverName)
```
    Description copied from interface: AsyncAdmin
    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)
 
```
    Specified by:
    
    coprocessorService in interface AsyncAdmin
    
    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
  - clearDeadServers
```
public CompletableFuture<List<ServerName>> clearDeadServers(List<ServerName> servers)
```
    Description copied from interface: AsyncAdmin
    
    Clear dead region servers from master.
    
    Specified by:
    
    clearDeadServers in interface AsyncAdmin
    
    Parameters:
    
    servers - list of dead region servers.
    
    Returns:
    
    - returns a list of servers that not cleared wrapped by a CompletableFuture.
  - newServerCaller
```
private <T> AsyncRpcRetryingCallerFactory.ServerRequestCallerBuilder<T> newServerCaller()
```
  - enableTableReplication
```
public CompletableFuture<Void> enableTableReplication(TableName tableName)
```
    Description copied from interface: AsyncAdmin
    
    Enable a table's replication switch.
    
    Specified by:
    
    enableTableReplication in interface AsyncAdmin
    
    Parameters:
    
    tableName - name of the table
  - disableTableReplication
```
public CompletableFuture<Void> disableTableReplication(TableName tableName)
```
    Description copied from interface: AsyncAdmin
    
    Disable a table's replication switch.
    
    Specified by:
    
    disableTableReplication in interface AsyncAdmin
    
    Parameters:
    
    tableName - name of the table
  - getTableSplits
```
private CompletableFuture<byte[][]> getTableSplits(TableName tableName)
```
  - checkAndSyncTableToPeerClusters
```
private CompletableFuture<Void> checkAndSyncTableToPeerClusters(TableName tableName,
                                                                byte[][] splits)
```
    Connect to peer and check the table descriptor on peer:
    1. Create the same table on peer when not exist.
    2. Throw an exception if the table already has replication enabled on any of the column families.
    3. Throw an exception if the table exists on peer cluster but descriptors are not same.
    Parameters:
    
    tableName - name of the table to sync to the peer
    
    splits - table split keys
  - trySyncTableToPeerCluster
```
private CompletableFuture<Void> trySyncTableToPeerCluster(TableName tableName,
                                                          byte[][] splits,
                                                          ReplicationPeerDescription peer)
```
  - compareTableWithPeerCluster
```
private CompletableFuture<Void> compareTableWithPeerCluster(TableName tableName,
                                                            TableDescriptor tableDesc,
                                                            ReplicationPeerDescription peer,
                                                            AsyncAdmin peerAdmin)
```
  - setTableReplication
```
private CompletableFuture<Void> setTableReplication(TableName tableName,
                                                    boolean enableRep)
```
    Set the table's replication switch if the table's replication switch is already not set.
    
    Parameters:
    
    tableName - name of the table
    
    enableRep - is replication switch enable or disable
  - clearBlockCache
```
public CompletableFuture<CacheEvictionStats> clearBlockCache(TableName tableName)
```
    Description copied from interface: AsyncAdmin
    
    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 AsyncAdmin
    
    Parameters:
    
    tableName - table to clear block cache
    
    Returns:
    
    CacheEvictionStats related to the eviction wrapped by a CompletableFuture.
  - cloneTableSchema
```
public CompletableFuture<Void> cloneTableSchema(TableName tableName,
                                                TableName newTableName,
                                                boolean preserveSplits)
```
    Description copied from interface: AsyncAdmin
    
    Create a new table by cloning the existent table schema.
    
    Specified by:
    
    cloneTableSchema in interface AsyncAdmin
    
    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
  - clearBlockCache
```
private CompletableFuture<CacheEvictionStats> clearBlockCache(ServerName serverName,
                                                              List<RegionInfo> hris)
```
  - switchRpcThrottle
```
public CompletableFuture<Boolean> switchRpcThrottle(boolean enable)
```
    Description copied from interface: AsyncAdmin
    
    Switch the rpc throttle enabled state.
    
    Specified by:
    
    switchRpcThrottle in interface AsyncAdmin
    
    Parameters:
    
    enable - Set to true to enable, false to disable.
    
    Returns:
    
    Previous rpc throttle enabled value
  - isRpcThrottleEnabled
```
public CompletableFuture<Boolean> isRpcThrottleEnabled()
```
    Description copied from interface: AsyncAdmin
    
    Get if the rpc throttle is enabled.
    
    Specified by:
    
    isRpcThrottleEnabled in interface AsyncAdmin
    
    Returns:
    
    True if rpc throttle is enabled
  - exceedThrottleQuotaSwitch
```
public CompletableFuture<Boolean> exceedThrottleQuotaSwitch(boolean enable)
```
    Description copied from interface: AsyncAdmin
    
    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 AsyncAdmin
    
    Parameters:
    
    enable - Set to true to enable, false to disable.
    
    Returns:
    
    Previous exceed throttle enabled value
  - getSpaceQuotaTableSizes
```
public CompletableFuture<Map<TableName,Long>> getSpaceQuotaTableSizes()
```
    Description copied from interface: AsyncAdmin
    
    Fetches the table sizes on the filesystem as tracked by the HBase Master.
    
    Specified by:
    
    getSpaceQuotaTableSizes in interface AsyncAdmin
  - getRegionServerSpaceQuotaSnapshots
```
public CompletableFuture<Map<TableName,SpaceQuotaSnapshot>> getRegionServerSpaceQuotaSnapshots(ServerName serverName)
```
    Description copied from interface: AsyncAdmin
    
    Fetches the observed SpaceQuotaSnapshotViews observed by a RegionServer.
    
    Specified by:
    
    getRegionServerSpaceQuotaSnapshots in interface AsyncAdmin
  - getCurrentSpaceQuotaSnapshot
```
private CompletableFuture<SpaceQuotaSnapshot> getCurrentSpaceQuotaSnapshot(RawAsyncHBaseAdmin.Converter<SpaceQuotaSnapshot,org.apache.hadoop.hbase.shaded.protobuf.generated.QuotaProtos.GetQuotaStatesResponse> converter)
```
  - getCurrentSpaceQuotaSnapshot
```
public CompletableFuture<SpaceQuotaSnapshot> getCurrentSpaceQuotaSnapshot(String namespace)
```
    Description copied from interface: AsyncAdmin
    
    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 AsyncAdmin
  - getCurrentSpaceQuotaSnapshot
```
public CompletableFuture<SpaceQuotaSnapshot> getCurrentSpaceQuotaSnapshot(TableName tableName)
```
    Description copied from interface: AsyncAdmin
    
    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 AsyncAdmin
  - grant
```
public CompletableFuture<Void> grant(UserPermission userPermission,
                                     boolean mergeExistingPermissions)
```
    Description copied from interface: AsyncAdmin
    
    Grants user specific permissions
    
    Specified by:
    
    grant in interface AsyncAdmin
    
    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
```
public CompletableFuture<Void> revoke(UserPermission userPermission)
```
    Description copied from interface: AsyncAdmin
    
    Revokes user specific permissions
    
    Specified by:
    
    revoke in interface AsyncAdmin
    
    Parameters:
    
    userPermission - user name and the specific permission
  - getUserPermissions
```
public CompletableFuture<List<UserPermission>> getUserPermissions(GetUserPermissionsRequest getUserPermissionsRequest)
```
    Description copied from interface: AsyncAdmin
    
    Get the global/namespace/table permissions for user
    
    Specified by:
    
    getUserPermissions in interface AsyncAdmin
    
    Parameters:
    
    getUserPermissionsRequest - A request contains which user, global, namespace or table permissions needed
    
    Returns:
    
    The user and permission list
  - hasUserPermissions
```
public CompletableFuture<List<Boolean>> hasUserPermissions(String userName,
                                                           List<Permission> permissions)
```
    Description copied from interface: AsyncAdmin
    
    Check if the user has specific permissions
    
    Specified by:
    
    hasUserPermissions in interface AsyncAdmin
    
    Parameters:
    
    userName - the user name
    
    permissions - the specific permission list
    
    Returns:
    
    True if user has the specific permissions
  - snapshotCleanupSwitch
```
public CompletableFuture<Boolean> snapshotCleanupSwitch(boolean on,
                                                        boolean sync)
```
    Description copied from interface: AsyncAdmin
    
    Turn on or off the auto snapshot cleanup based on TTL.
    Notice that, the method itself is always non-blocking, which means it will always return immediately. The sync parameter only effects when will we complete the returned CompletableFuture.
    
    Specified by:
    
    snapshotCleanupSwitch in interface AsyncAdmin
    
    Parameters:
    
    on - Set to true to enable, false to disable.
    
    sync - If true, it waits until current snapshot cleanup is completed, if outstanding.
    
    Returns:
    
    Previous auto snapshot cleanup value wrapped by a CompletableFuture.
  - isSnapshotCleanupEnabled
```
public CompletableFuture<Boolean> isSnapshotCleanupEnabled()
```
    Description copied from interface: AsyncAdmin
    
    Query the current state of the auto snapshot cleanup based on TTL.
    
    Specified by:
    
    isSnapshotCleanupEnabled in interface AsyncAdmin
    
    Returns:
    
    true if the auto snapshot cleanup is enabled, false otherwise. The return value will be wrapped by a CompletableFuture.
  - getSlowLogResponses
```
private CompletableFuture<List<LogEntry>> getSlowLogResponses(Map<String,Object> filterParams,
                                                              Set<ServerName> serverNames,
                                                              int limit,
                                                              String logType)
```
  - getSlowLogResponseFromServer
```
private CompletableFuture<List<LogEntry>> getSlowLogResponseFromServer(ServerName serverName,
                                                                       Map<String,Object> filterParams,
                                                                       int limit,
                                                                       String logType)
```
  - clearSlowLogResponses
```
public CompletableFuture<List<Boolean>> clearSlowLogResponses(@Nullable
                                                              Set<ServerName> serverNames)
```
    Description copied from interface: AsyncAdmin
    
    Clears online slow RPC logs from the provided list of RegionServers
    
    Specified by:
    
    clearSlowLogResponses in interface AsyncAdmin
    
    Parameters:
    
    serverNames - Set of Server names to clean slowlog responses from
    
    Returns:
    
    List of booleans representing if online slowlog response buffer is cleaned from each RegionServer. The return value wrapped by a CompletableFuture
  - clearSlowLogsResponses
```
private CompletableFuture<Boolean> clearSlowLogsResponses(ServerName serverName)
```
  - convertToFutureOfList
```
private static <T> CompletableFuture<List<T>> convertToFutureOfList(List<CompletableFuture<T>> futures)
```
  - getBalancerDecisions
```
private CompletableFuture<List<LogEntry>> getBalancerDecisions(int limit)
```
  - getBalancerRejections
```
private CompletableFuture<List<LogEntry>> getBalancerRejections(int limit)
```
  - getLogEntries
```
public CompletableFuture<List<LogEntry>> getLogEntries(Set<ServerName> serverNames,
                                                       String logType,
                                                       ServerType serverType,
                                                       int limit,
                                                       Map<String,Object> filterParams)
```
    Description copied from interface: AsyncAdmin
    
    Retrieve recent online records from HMaster / RegionServers. Examples include slow/large RPC logs, balancer decisions by master.
    
    Specified by:
    
    getLogEntries in interface AsyncAdmin
    
    Parameters:
    
    serverNames - servers to retrieve records from, useful in case of records maintained by RegionServer as we can select specific server. In case of servertype=MASTER, logs will only come from the currently active master.
    
    logType - string representing type of log records
    
    serverType - enum for server type: HMaster or RegionServer
    
    limit - put a limit to list of records that server should send in response
    
    filterParams - additional filter params
  - flushMasterStore
```
public CompletableFuture<Void> flushMasterStore()
```
    Description copied from interface: AsyncAdmin
    
    Flush master local region
    
    Specified by:
    
    flushMasterStore in interface AsyncAdmin

Class RawAsyncHBaseAdmin

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.AsyncAdmin

Field Detail

FLUSH_TABLE_PROCEDURE_SIGNATURE

LOG

connection

retryTimer

metaTable

rpcTimeoutNs

operationTimeoutNs

pauseNs

pauseNsForServerOverloaded

maxAttempts

startLogErrorsCnt

ng

Constructor Detail

RawAsyncHBaseAdmin

Method Detail

newMasterCaller

newAdminCaller

call

adminCall

procedureCall

procedureCall

procedureCall

tableExists

listTableDescriptors

listTableDescriptors

listTableDescriptors

getTableDescriptors

listTableNames

listTableNames

getTableNames

listTableDescriptorsByNamespace

listTableNamesByNamespace

getDescriptor

createTable

createTable

createTable

createTable

modifyTable

modifyTableStoreFileTracker

deleteTable

truncateTable

enableTable

disableTable

completeCheckTableState

isTableEnabled

isTableDisabled

isTableAvailable

isTableAvailable

isTableAvailable

compareRegionsWithSplitKeys

addColumnFamily

deleteColumnFamily

modifyColumnFamily

modifyColumnFamilyStoreFileTracker

createNamespace

modifyNamespace

deleteNamespace

getNamespaceDescriptor

listNamespaces

listNamespaceDescriptors

getRegions

getRegions

flush

flush

flushRegion

flushRegion

flush

flushRegionServer

compact

compact

compactRegion

compactRegion