• Home
• org.apache.hbase
• hbase-client
• 2.6.0
• source code
• AsyncHBaseAdmin.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

org.apache.hadoop.hbase.client.AsyncHBaseAdmin Maven / Gradle / Ivy

/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.apache.hadoop.hbase.client;

import com.google.protobuf.RpcChannel;
import java.util.EnumSet;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutorService;
import java.util.function.Function;
import java.util.regex.Pattern;
import org.apache.hadoop.hbase.CacheEvictionStats;
import org.apache.hadoop.hbase.ClusterMetrics;
import org.apache.hadoop.hbase.ClusterMetrics.Option;
import org.apache.hadoop.hbase.NamespaceDescriptor;
import org.apache.hadoop.hbase.RegionMetrics;
import org.apache.hadoop.hbase.ServerName;
import org.apache.hadoop.hbase.TableName;
import org.apache.hadoop.hbase.client.replication.TableCFs;
import org.apache.hadoop.hbase.client.security.SecurityCapability;
import org.apache.hadoop.hbase.quotas.QuotaFilter;
import org.apache.hadoop.hbase.quotas.QuotaSettings;
import org.apache.hadoop.hbase.quotas.SpaceQuotaSnapshot;
import org.apache.hadoop.hbase.replication.ReplicationPeerConfig;
import org.apache.hadoop.hbase.replication.ReplicationPeerDescription;
import org.apache.hadoop.hbase.security.access.GetUserPermissionsRequest;
import org.apache.hadoop.hbase.security.access.Permission;
import org.apache.hadoop.hbase.security.access.UserPermission;
import org.apache.hadoop.hbase.util.FutureUtils;
import org.apache.yetus.audience.InterfaceAudience;

/**
 * Just a wrapper of {@link RawAsyncHBaseAdmin}. The difference is that users need to provide a
 * thread pool when constructing this class, and the callback methods registered to the returned
 * {@link CompletableFuture} will be executed in this thread pool. So usually it is safe for users
 * to do anything they want in the callbacks without breaking the rpc framework.
 * @since 2.0.0
 * @see RawAsyncHBaseAdmin
 * @see AsyncConnection#getAdmin(ExecutorService)
 * @see AsyncConnection#getAdminBuilder(ExecutorService)
 */
@InterfaceAudience.Private
class AsyncHBaseAdmin implements AsyncAdmin {

  private final RawAsyncHBaseAdmin rawAdmin;

  private final ExecutorService pool;

  AsyncHBaseAdmin(RawAsyncHBaseAdmin rawAdmin, ExecutorService pool) {
    this.rawAdmin = rawAdmin;
    this.pool = pool;
  }

  private  CompletableFuture wrap(CompletableFuture future) {
    return FutureUtils.wrapFuture(future, pool);
  }

  @Override
  public CompletableFuture tableExists(TableName tableName) {
    return wrap(rawAdmin.tableExists(tableName));
  }

  @Override
  public CompletableFuture> listTableDescriptors(boolean includeSysTables) {
    return wrap(rawAdmin.listTableDescriptors(includeSysTables));
  }

  @Override
  public CompletableFuture> listTableDescriptors(Pattern pattern,
    boolean includeSysTables) {
    return wrap(rawAdmin.listTableDescriptors(pattern, includeSysTables));
  }

  @Override
  public CompletableFuture> listTableDescriptors(List tableNames) {
    return wrap(rawAdmin.listTableDescriptors(tableNames));
  }

  @Override
  public CompletableFuture> listTableDescriptorsByNamespace(String name) {
    return wrap(rawAdmin.listTableDescriptorsByNamespace(name));
  }

  @Override
  public CompletableFuture> listTableDescriptorsByState(boolean isEnabled) {
    return wrap(rawAdmin.listTableDescriptorsByState(isEnabled));
  }

  @Override
  public CompletableFuture> listTableNames(boolean includeSysTables) {
    return wrap(rawAdmin.listTableNames(includeSysTables));
  }

  @Override
  public CompletableFuture> listTableNames(Pattern pattern,
    boolean includeSysTables) {
    return wrap(rawAdmin.listTableNames(pattern, includeSysTables));
  }

  @Override
  public CompletableFuture> listTableNamesByNamespace(String name) {
    return wrap(rawAdmin.listTableNamesByNamespace(name));
  }

  @Override
  public CompletableFuture> listTableNamesByState(boolean isEnabled) {
    return wrap(rawAdmin.listTableNamesByState(isEnabled));
  }

  @Override
  public CompletableFuture getDescriptor(TableName tableName) {
    return wrap(rawAdmin.getDescriptor(tableName));
  }

  @Override
  public CompletableFuture createTable(TableDescriptor desc) {
    return wrap(rawAdmin.createTable(desc));
  }

  @Override
  public CompletableFuture createTable(TableDescriptor desc, byte[] startKey, byte[] endKey,
    int numRegions) {
    return wrap(rawAdmin.createTable(desc, startKey, endKey, numRegions));
  }

  @Override
  public CompletableFuture createTable(TableDescriptor desc, byte[][] splitKeys) {
    return wrap(rawAdmin.createTable(desc, splitKeys));
  }

  @Override
  public CompletableFuture modifyTable(TableDescriptor desc) {
    return modifyTable(desc, true);
  }

  @Override
  public CompletableFuture modifyTable(TableDescriptor desc, boolean reopenRegions) {
    return wrap(rawAdmin.modifyTable(desc, reopenRegions));
  }

  @Override
  public CompletableFuture modifyTableStoreFileTracker(TableName tableName, String dstSFT) {
    return wrap(rawAdmin.modifyTableStoreFileTracker(tableName, dstSFT));
  }

  @Override
  public CompletableFuture deleteTable(TableName tableName) {
    return wrap(rawAdmin.deleteTable(tableName));
  }

  @Override
  public CompletableFuture truncateTable(TableName tableName, boolean preserveSplits) {
    return wrap(rawAdmin.truncateTable(tableName, preserveSplits));
  }

  @Override
  public CompletableFuture enableTable(TableName tableName) {
    return wrap(rawAdmin.enableTable(tableName));
  }

  @Override
  public CompletableFuture disableTable(TableName tableName) {
    return wrap(rawAdmin.disableTable(tableName));
  }

  @Override
  public CompletableFuture isTableEnabled(TableName tableName) {
    return wrap(rawAdmin.isTableEnabled(tableName));
  }

  @Override
  public CompletableFuture isTableDisabled(TableName tableName) {
    return wrap(rawAdmin.isTableDisabled(tableName));
  }

  @Override
  public CompletableFuture isTableAvailable(TableName tableName) {
    return wrap(rawAdmin.isTableAvailable(tableName));
  }

  @Override
  public CompletableFuture isTableAvailable(TableName tableName, byte[][] splitKeys) {
    return wrap(rawAdmin.isTableAvailable(tableName, splitKeys));
  }

  @Override
  public CompletableFuture addColumnFamily(TableName tableName,
    ColumnFamilyDescriptor columnFamily) {
    return wrap(rawAdmin.addColumnFamily(tableName, columnFamily));
  }

  @Override
  public CompletableFuture deleteColumnFamily(TableName tableName, byte[] columnFamily) {
    return wrap(rawAdmin.deleteColumnFamily(tableName, columnFamily));
  }

  @Override
  public CompletableFuture modifyColumnFamily(TableName tableName,
    ColumnFamilyDescriptor columnFamily) {
    return wrap(rawAdmin.modifyColumnFamily(tableName, columnFamily));
  }

  @Override
  public CompletableFuture modifyColumnFamilyStoreFileTracker(TableName tableName,
    byte[] family, String dstSFT) {
    return wrap(rawAdmin.modifyColumnFamilyStoreFileTracker(tableName, family, dstSFT));
  }

  @Override
  public CompletableFuture createNamespace(NamespaceDescriptor descriptor) {
    return wrap(rawAdmin.createNamespace(descriptor));
  }

  @Override
  public CompletableFuture modifyNamespace(NamespaceDescriptor descriptor) {
    return wrap(rawAdmin.modifyNamespace(descriptor));
  }

  @Override
  public CompletableFuture deleteNamespace(String name) {
    return wrap(rawAdmin.deleteNamespace(name));
  }

  @Override
  public CompletableFuture getNamespaceDescriptor(String name) {
    return wrap(rawAdmin.getNamespaceDescriptor(name));
  }

  @Override
  public CompletableFuture> listNamespaces() {
    return wrap(rawAdmin.listNamespaces());
  }

  @Override
  public CompletableFuture> listNamespaceDescriptors() {
    return wrap(rawAdmin.listNamespaceDescriptors());
  }

  @Override
  public CompletableFuture> getRegions(ServerName serverName) {
    return wrap(rawAdmin.getRegions(serverName));
  }

  @Override
  public CompletableFuture> getRegions(TableName tableName) {
    return wrap(rawAdmin.getRegions(tableName));
  }

  @Override
  public CompletableFuture flush(TableName tableName) {
    return wrap(rawAdmin.flush(tableName));
  }

  @Override
  public CompletableFuture flush(TableName tableName, byte[] columnFamily) {
    return wrap(rawAdmin.flush(tableName, columnFamily));
  }

  @Override
  public CompletableFuture flush(TableName tableName, List columnFamilies) {
    return wrap(rawAdmin.flush(tableName, columnFamilies));
  }

  @Override
  public CompletableFuture flushRegion(byte[] regionName) {
    return wrap(rawAdmin.flushRegion(regionName));
  }

  @Override
  public CompletableFuture flushRegion(byte[] regionName, byte[] columnFamily) {
    return wrap(rawAdmin.flushRegion(regionName, columnFamily));
  }

  @Override
  public CompletableFuture flushRegionServer(ServerName sn) {
    return wrap(rawAdmin.flushRegionServer(sn));
  }

  @Override
  public CompletableFuture compact(TableName tableName, CompactType compactType) {
    return wrap(rawAdmin.compact(tableName, compactType));
  }

  @Override
  public CompletableFuture compact(TableName tableName, byte[] columnFamily,
    CompactType compactType) {
    return wrap(rawAdmin.compact(tableName, columnFamily, compactType));
  }

  @Override
  public CompletableFuture compactRegion(byte[] regionName) {
    return wrap(rawAdmin.compactRegion(regionName));
  }

  @Override
  public CompletableFuture compactRegion(byte[] regionName, byte[] columnFamily) {
    return wrap(rawAdmin.compactRegion(regionName, columnFamily));
  }

  @Override
  public CompletableFuture majorCompact(TableName tableName, CompactType compactType) {
    return wrap(rawAdmin.majorCompact(tableName, compactType));
  }

  @Override
  public CompletableFuture majorCompact(TableName tableName, byte[] columnFamily,
    CompactType compactType) {
    return wrap(rawAdmin.majorCompact(tableName, columnFamily, compactType));
  }

  @Override
  public CompletableFuture majorCompactRegion(byte[] regionName) {
    return wrap(rawAdmin.majorCompactRegion(regionName));
  }

  @Override
  public CompletableFuture majorCompactRegion(byte[] regionName, byte[] columnFamily) {
    return wrap(rawAdmin.majorCompactRegion(regionName, columnFamily));
  }

  @Override
  public CompletableFuture compactRegionServer(ServerName serverName) {
    return wrap(rawAdmin.compactRegionServer(serverName));
  }

  @Override
  public CompletableFuture majorCompactRegionServer(ServerName serverName) {
    return wrap(rawAdmin.majorCompactRegionServer(serverName));
  }

  @Override
  public CompletableFuture mergeSwitch(boolean enabled, boolean drainMerges) {
    return wrap(rawAdmin.mergeSwitch(enabled, drainMerges));
  }

  @Override
  public CompletableFuture isMergeEnabled() {
    return wrap(rawAdmin.isMergeEnabled());
  }

  @Override
  public CompletableFuture splitSwitch(boolean enabled, boolean drainSplits) {
    return wrap(rawAdmin.splitSwitch(enabled, drainSplits));
  }

  @Override
  public CompletableFuture isSplitEnabled() {
    return wrap(rawAdmin.isSplitEnabled());
  }

  @Override
  public CompletableFuture mergeRegions(List nameOfRegionsToMerge, boolean forcible) {
    return wrap(rawAdmin.mergeRegions(nameOfRegionsToMerge, forcible));
  }

  @Override
  public CompletableFuture split(TableName tableName) {
    return wrap(rawAdmin.split(tableName));
  }

  @Override
  public CompletableFuture split(TableName tableName, byte[] splitPoint) {
    return wrap(rawAdmin.split(tableName, splitPoint));
  }

  @Override
  public CompletableFuture splitRegion(byte[] regionName) {
    return wrap(rawAdmin.splitRegion(regionName));
  }

  @Override
  public CompletableFuture splitRegion(byte[] regionName, byte[] splitPoint) {
    return wrap(rawAdmin.splitRegion(regionName, splitPoint));
  }

  @Override
  public CompletableFuture truncateRegion(byte[] regionName) {
    return wrap(rawAdmin.truncateRegion(regionName));
  }

  @Override
  public CompletableFuture assign(byte[] regionName) {
    return wrap(rawAdmin.assign(regionName));
  }

  @Override
  public CompletableFuture unassign(byte[] regionName) {
    return wrap(rawAdmin.unassign(regionName));
  }

  @Override
  public CompletableFuture offline(byte[] regionName) {
    return wrap(rawAdmin.offline(regionName));
  }

  @Override
  public CompletableFuture move(byte[] regionName) {
    return wrap(rawAdmin.move(regionName));
  }

  @Override
  public CompletableFuture move(byte[] regionName, ServerName destServerName) {
    return wrap(rawAdmin.move(regionName, destServerName));
  }

  @Override
  public CompletableFuture setQuota(QuotaSettings quota) {
    return wrap(rawAdmin.setQuota(quota));
  }

  @Override
  public CompletableFuture> getQuota(QuotaFilter filter) {
    return wrap(rawAdmin.getQuota(filter));
  }

  @Override
  public CompletableFuture addReplicationPeer(String peerId, ReplicationPeerConfig peerConfig,
    boolean enabled) {
    return wrap(rawAdmin.addReplicationPeer(peerId, peerConfig, enabled));
  }

  @Override
  public CompletableFuture removeReplicationPeer(String peerId) {
    return wrap(rawAdmin.removeReplicationPeer(peerId));
  }

  @Override
  public CompletableFuture enableReplicationPeer(String peerId) {
    return wrap(rawAdmin.enableReplicationPeer(peerId));
  }

  @Override
  public CompletableFuture disableReplicationPeer(String peerId) {
    return wrap(rawAdmin.disableReplicationPeer(peerId));
  }

  @Override
  public CompletableFuture getReplicationPeerConfig(String peerId) {
    return wrap(rawAdmin.getReplicationPeerConfig(peerId));
  }

  @Override
  public CompletableFuture updateReplicationPeerConfig(String peerId,
    ReplicationPeerConfig peerConfig) {
    return wrap(rawAdmin.updateReplicationPeerConfig(peerId, peerConfig));
  }

  @Override
  public CompletableFuture appendReplicationPeerTableCFs(String peerId,
    Map> tableCfs) {
    return wrap(rawAdmin.appendReplicationPeerTableCFs(peerId, tableCfs));
  }

  @Override
  public CompletableFuture removeReplicationPeerTableCFs(String peerId,
    Map> tableCfs) {
    return wrap(rawAdmin.removeReplicationPeerTableCFs(peerId, tableCfs));
  }

  @Override
  public CompletableFuture> listReplicationPeers() {
    return wrap(rawAdmin.listReplicationPeers());
  }

  @Override
  public CompletableFuture> listReplicationPeers(Pattern pattern) {
    return wrap(rawAdmin.listReplicationPeers(pattern));
  }

  @Override
  public CompletableFuture> listReplicatedTableCFs() {
    return wrap(rawAdmin.listReplicatedTableCFs());
  }

  @Override
  public CompletableFuture enableTableReplication(TableName tableName) {
    return wrap(rawAdmin.enableTableReplication(tableName));
  }

  @Override
  public CompletableFuture disableTableReplication(TableName tableName) {
    return wrap(rawAdmin.disableTableReplication(tableName));
  }

  @Override
  public CompletableFuture isReplicationPeerEnabled(String peerId) {
    return wrap(rawAdmin.isReplicationPeerEnabled(peerId));
  }

  @Override
  public CompletableFuture replicationPeerModificationSwitch(boolean on,
    boolean drainProcedures) {
    return wrap(rawAdmin.replicationPeerModificationSwitch(on, drainProcedures));
  }

  @Override
  public CompletableFuture isReplicationPeerModificationEnabled() {
    return wrap(rawAdmin.isReplicationPeerModificationEnabled());
  }

  @Override
  public CompletableFuture snapshot(SnapshotDescription snapshot) {
    return wrap(rawAdmin.snapshot(snapshot));
  }

  @Override
  public CompletableFuture isSnapshotFinished(SnapshotDescription snapshot) {
    return wrap(rawAdmin.isSnapshotFinished(snapshot));
  }

  @Override
  public CompletableFuture restoreSnapshot(String snapshotName) {
    return wrap(rawAdmin.restoreSnapshot(snapshotName));
  }

  @Override
  public CompletableFuture restoreSnapshot(String snapshotName, boolean takeFailSafeSnapshot,
    boolean restoreAcl) {
    return wrap(rawAdmin.restoreSnapshot(snapshotName, takeFailSafeSnapshot, restoreAcl));
  }

  @Override
  public CompletableFuture cloneSnapshot(String snapshotName, TableName tableName,
    boolean restoreAcl, String customSFT) {
    return wrap(rawAdmin.cloneSnapshot(snapshotName, tableName, restoreAcl, customSFT));
  }

  @Override
  public CompletableFuture> listSnapshots() {
    return wrap(rawAdmin.listSnapshots());
  }

  @Override
  public CompletableFuture> listSnapshots(Pattern pattern) {
    return wrap(rawAdmin.listSnapshots(pattern));
  }

  @Override
  public CompletableFuture> listTableSnapshots(Pattern tableNamePattern) {
    return wrap(rawAdmin.listTableSnapshots(tableNamePattern));
  }

  @Override
  public CompletableFuture> listTableSnapshots(Pattern tableNamePattern,
    Pattern snapshotNamePattern) {
    return wrap(rawAdmin.listTableSnapshots(tableNamePattern, snapshotNamePattern));
  }

  @Override
  public CompletableFuture deleteSnapshot(String snapshotName) {
    return wrap(rawAdmin.deleteSnapshot(snapshotName));
  }

  @Override
  public CompletableFuture deleteSnapshots() {
    return wrap(rawAdmin.deleteSnapshots());
  }

  @Override
  public CompletableFuture deleteSnapshots(Pattern pattern) {
    return wrap(rawAdmin.deleteSnapshots(pattern));
  }

  @Override
  public CompletableFuture deleteTableSnapshots(Pattern tableNamePattern) {
    return wrap(rawAdmin.deleteTableSnapshots(tableNamePattern));
  }

  @Override
  public CompletableFuture deleteTableSnapshots(Pattern tableNamePattern,
    Pattern snapshotNamePattern) {
    return wrap(rawAdmin.deleteTableSnapshots(tableNamePattern, snapshotNamePattern));
  }

  @Override
  public CompletableFuture execProcedure(String signature, String instance,
    Map props) {
    return wrap(rawAdmin.execProcedure(signature, instance, props));
  }

  @Override
  public CompletableFuture execProcedureWithReturn(String signature, String instance,
    Map props) {
    return wrap(rawAdmin.execProcedureWithReturn(signature, instance, props));
  }

  @Override
  public CompletableFuture isProcedureFinished(String signature, String instance,
    Map props) {
    return wrap(rawAdmin.isProcedureFinished(signature, instance, props));
  }

  @Override
  public CompletableFuture abortProcedure(long procId, boolean mayInterruptIfRunning) {
    return wrap(rawAdmin.abortProcedure(procId, mayInterruptIfRunning));
  }

  @Override
  public CompletableFuture getProcedures() {
    return wrap(rawAdmin.getProcedures());
  }

  @Override
  public CompletableFuture getLocks() {
    return wrap(rawAdmin.getLocks());
  }

  @Override
  public CompletableFuture decommissionRegionServers(List servers,
    boolean offload) {
    return wrap(rawAdmin.decommissionRegionServers(servers, offload));
  }

  @Override
  public CompletableFuture> listDecommissionedRegionServers() {
    return wrap(rawAdmin.listDecommissionedRegionServers());
  }

  @Override
  public CompletableFuture recommissionRegionServer(ServerName server,
    List encodedRegionNames) {
    return wrap(rawAdmin.recommissionRegionServer(server, encodedRegionNames));
  }

  @Override
  public CompletableFuture getClusterMetrics() {
    return getClusterMetrics(EnumSet.allOf(Option.class));
  }

  @Override
  public CompletableFuture getClusterMetrics(EnumSet options) {
    return wrap(rawAdmin.getClusterMetrics(options));
  }

  @Override
  public CompletableFuture shutdown() {
    return wrap(rawAdmin.shutdown());
  }

  @Override
  public CompletableFuture stopMaster() {
    return wrap(rawAdmin.stopMaster());
  }

  @Override
  public CompletableFuture stopRegionServer(ServerName serverName) {
    return wrap(rawAdmin.stopRegionServer(serverName));
  }

  @Override
  public CompletableFuture updateConfiguration(ServerName serverName) {
    return wrap(rawAdmin.updateConfiguration(serverName));
  }

  @Override
  public CompletableFuture updateConfiguration() {
    return wrap(rawAdmin.updateConfiguration());
  }

  @Override
  public CompletableFuture rollWALWriter(ServerName serverName) {
    return wrap(rawAdmin.rollWALWriter(serverName));
  }

  @Override
  public CompletableFuture clearCompactionQueues(ServerName serverName, Set queues) {
    return wrap(rawAdmin.clearCompactionQueues(serverName, queues));
  }

  @Override
  public CompletableFuture> getSecurityCapabilities() {
    return wrap(rawAdmin.getSecurityCapabilities());
  }

  @Override
  public CompletableFuture> getRegionMetrics(ServerName serverName) {
    return wrap(rawAdmin.getRegionMetrics(serverName));
  }

  @Override
  public CompletableFuture> getRegionMetrics(ServerName serverName,
    TableName tableName) {
    return wrap(rawAdmin.getRegionMetrics(serverName, tableName));
  }

  @Override
  public CompletableFuture isMasterInMaintenanceMode() {
    return wrap(rawAdmin.isMasterInMaintenanceMode());
  }

  @Override
  public CompletableFuture getCompactionState(TableName tableName,
    CompactType compactType) {
    return wrap(rawAdmin.getCompactionState(tableName, compactType));
  }

  @Override
  public CompletableFuture getCompactionStateForRegion(byte[] regionName) {
    return wrap(rawAdmin.getCompactionStateForRegion(regionName));
  }

  @Override
  public CompletableFuture> getLastMajorCompactionTimestamp(TableName tableName) {
    return wrap(rawAdmin.getLastMajorCompactionTimestamp(tableName));
  }

  @Override
  public CompletableFuture>
    getLastMajorCompactionTimestampForRegion(byte[] regionName) {
    return wrap(rawAdmin.getLastMajorCompactionTimestampForRegion(regionName));
  }

  @Override
  public CompletableFuture balancerSwitch(boolean on, boolean drainRITs) {
    return wrap(rawAdmin.balancerSwitch(on, drainRITs));
  }

  @Override
  public CompletableFuture balance(BalanceRequest request) {
    return wrap(rawAdmin.balance(request));
  }

  @Override
  public CompletableFuture isBalancerEnabled() {
    return wrap(rawAdmin.isBalancerEnabled());
  }

  @Override
  public CompletableFuture normalizerSwitch(boolean on) {
    return wrap(rawAdmin.normalizerSwitch(on));
  }

  @Override
  public CompletableFuture isNormalizerEnabled() {
    return wrap(rawAdmin.isNormalizerEnabled());
  }

  @Override
  public CompletableFuture normalize(NormalizeTableFilterParams ntfp) {
    return wrap(rawAdmin.normalize(ntfp));
  }

  @Override
  public CompletableFuture cleanerChoreSwitch(boolean enabled) {
    return wrap(rawAdmin.cleanerChoreSwitch(enabled));
  }

  @Override
  public CompletableFuture isCleanerChoreEnabled() {
    return wrap(rawAdmin.isCleanerChoreEnabled());
  }

  @Override
  public CompletableFuture runCleanerChore() {
    return wrap(rawAdmin.runCleanerChore());
  }

  @Override
  public CompletableFuture catalogJanitorSwitch(boolean enabled) {
    return wrap(rawAdmin.catalogJanitorSwitch(enabled));
  }

  @Override
  public CompletableFuture isCatalogJanitorEnabled() {
    return wrap(rawAdmin.isCatalogJanitorEnabled());
  }

  @Override
  public CompletableFuture runCatalogJanitor() {
    return wrap(rawAdmin.runCatalogJanitor());
  }

  @Override
  public  CompletableFuture coprocessorService(Function stubMaker,
    ServiceCaller callable) {
    return wrap(rawAdmin.coprocessorService(stubMaker, callable));
  }

  @Override
  public  CompletableFuture coprocessorService(Function stubMaker,
    ServiceCaller callable, ServerName serverName) {
    return wrap(rawAdmin.coprocessorService(stubMaker, callable, serverName));
  }

  @Override
  public CompletableFuture> listDeadServers() {
    return wrap(rawAdmin.listDeadServers());
  }

  @Override
  public CompletableFuture> listUnknownServers() {
    return wrap(rawAdmin.listUnknownServers());
  }

  @Override
  public CompletableFuture> clearDeadServers(List servers) {
    return wrap(rawAdmin.clearDeadServers(servers));
  }

  @Override
  public CompletableFuture clearBlockCache(TableName tableName) {
    return wrap(rawAdmin.clearBlockCache(tableName));
  }

  @Override
  public CompletableFuture cloneTableSchema(TableName tableName, TableName newTableName,
    boolean preserveSplits) {
    return wrap(rawAdmin.cloneTableSchema(tableName, newTableName, preserveSplits));
  }

  @Override
  public CompletableFuture> compactionSwitch(boolean switchState,
    List serverNamesList) {
    return wrap(rawAdmin.compactionSwitch(switchState, serverNamesList));
  }

  @Override
  public CompletableFuture switchRpcThrottle(boolean enable) {
    return wrap(rawAdmin.switchRpcThrottle(enable));
  }

  @Override
  public CompletableFuture isRpcThrottleEnabled() {
    return wrap(rawAdmin.isRpcThrottleEnabled());
  }

  @Override
  public CompletableFuture exceedThrottleQuotaSwitch(boolean enable) {
    return wrap(rawAdmin.exceedThrottleQuotaSwitch(enable));
  }

  @Override
  public CompletableFuture> getSpaceQuotaTableSizes() {
    return wrap(rawAdmin.getSpaceQuotaTableSizes());
  }

  @Override
  public CompletableFuture>
    getRegionServerSpaceQuotaSnapshots(ServerName serverName) {
    return wrap(rawAdmin.getRegionServerSpaceQuotaSnapshots(serverName));
  }

  @Override
  public CompletableFuture getCurrentSpaceQuotaSnapshot(String namespace) {
    return wrap(rawAdmin.getCurrentSpaceQuotaSnapshot(namespace));
  }

  @Override
  public CompletableFuture getCurrentSpaceQuotaSnapshot(TableName tableName) {
    return wrap(rawAdmin.getCurrentSpaceQuotaSnapshot(tableName));
  }

  @Override
  public CompletableFuture grant(UserPermission userPermission,
    boolean mergeExistingPermissions) {
    return wrap(rawAdmin.grant(userPermission, mergeExistingPermissions));
  }

  @Override
  public CompletableFuture revoke(UserPermission userPermission) {
    return wrap(rawAdmin.revoke(userPermission));
  }

  @Override
  public CompletableFuture>
    getUserPermissions(GetUserPermissionsRequest getUserPermissionsRequest) {
    return wrap(rawAdmin.getUserPermissions(getUserPermissionsRequest));
  }

  @Override
  public CompletableFuture> hasUserPermissions(String userName,
    List permissions) {
    return wrap(rawAdmin.hasUserPermissions(userName, permissions));
  }

  @Override
  public CompletableFuture snapshotCleanupSwitch(final boolean on, final boolean sync) {
    return wrap(rawAdmin.snapshotCleanupSwitch(on, sync));
  }

  @Override
  public CompletableFuture isSnapshotCleanupEnabled() {
    return wrap(rawAdmin.isSnapshotCleanupEnabled());
  }

  @Override
  public CompletableFuture> clearSlowLogResponses(Set serverNames) {
    return wrap(rawAdmin.clearSlowLogResponses(serverNames));
  }

  @Override
  public CompletableFuture> getLogEntries(Set serverNames,
    String logType, ServerType serverType, int limit, Map filterParams) {
    return wrap(rawAdmin.getLogEntries(serverNames, logType, serverType, limit, filterParams));
  }

  @Override
  public CompletableFuture flushMasterStore() {
    return wrap(rawAdmin.flushMasterStore());
  }

  @Override
  public CompletableFuture> getCachedFilesList(ServerName serverName) {
    return wrap(rawAdmin.getCachedFilesList(serverName));
  }
}