hbase-client/src/main/java/org/apache/hadoop/hbase/client/AsyncHBaseAdmin.java

   1 /*
   2  * Licensed to the Apache Software Foundation (ASF) under one
   3  * or more contributor license agreements.  See the NOTICE file
   4  * distributed with this work for additional information
   5  * regarding copyright ownership.  The ASF licenses this file
   6  * to you under the Apache License, Version 2.0 (the
   7  * "License"); you may not use this file except in compliance
   8  * with the License.  You may obtain a copy of the License at
   9  *
  10  *     http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  * Unless required by applicable law or agreed to in writing, software
  13  * distributed under the License is distributed on an "AS IS" BASIS,
  14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  * See the License for the specific language governing permissions and
  16  * limitations under the License.
  17  */
  18 package org.apache.hadoop.hbase.client;
  19
  20 import java.util.EnumSet;
  21 import java.util.List;
  22 import java.util.Map;
  23 import java.util.Optional;
  24 import java.util.Set;
  25 import java.util.concurrent.CompletableFuture;
  26 import java.util.concurrent.ExecutorService;
  27 import java.util.function.Function;
  28 import java.util.regex.Pattern;
  29 import org.apache.hadoop.hbase.CacheEvictionStats;
  30 import org.apache.hadoop.hbase.ClusterMetrics;
  31 import org.apache.hadoop.hbase.ClusterMetrics.Option;
  32 import org.apache.hadoop.hbase.NamespaceDescriptor;
  33 import org.apache.hadoop.hbase.RegionMetrics;
  34 import org.apache.hadoop.hbase.ServerName;
  35 import org.apache.hadoop.hbase.TableName;
  36 import org.apache.hadoop.hbase.client.replication.TableCFs;
  37 import org.apache.hadoop.hbase.client.security.SecurityCapability;
  38 import org.apache.hadoop.hbase.net.Address;
  39 import org.apache.hadoop.hbase.quotas.QuotaFilter;
  40 import org.apache.hadoop.hbase.quotas.QuotaSettings;
  41 import org.apache.hadoop.hbase.quotas.SpaceQuotaSnapshot;
  42 import org.apache.hadoop.hbase.replication.ReplicationPeerConfig;
  43 import org.apache.hadoop.hbase.replication.ReplicationPeerDescription;
  44 import org.apache.hadoop.hbase.replication.SyncReplicationState;
  45 import org.apache.hadoop.hbase.rsgroup.RSGroupInfo;
  46 import org.apache.hadoop.hbase.security.access.GetUserPermissionsRequest;
  47 import org.apache.hadoop.hbase.security.access.Permission;
  48 import org.apache.hadoop.hbase.security.access.UserPermission;
  49 import org.apache.hadoop.hbase.util.FutureUtils;
  50 import org.apache.hadoop.hbase.util.Pair;
  51 import org.apache.yetus.audience.InterfaceAudience;
  52
  53 import org.apache.hbase.thirdparty.com.google.protobuf.RpcChannel;
  54
  55 /**
  56  * Just a wrapper of {@link RawAsyncHBaseAdmin}. The difference is that users need to provide a
  57  * thread pool when constructing this class, and the callback methods registered to the returned
  58  * {@link CompletableFuture} will be executed in this thread pool. So usually it is safe for users
  59  * to do anything they want in the callbacks without breaking the rpc framework.
  60  * @since 2.0.0
  61  * @see RawAsyncHBaseAdmin
  62  * @see AsyncConnection#getAdmin(ExecutorService)
  63  * @see AsyncConnection#getAdminBuilder(ExecutorService)
  64  */
  65 @InterfaceAudience.Private
  66 class AsyncHBaseAdmin implements AsyncAdmin {
  67
  68   private final RawAsyncHBaseAdmin rawAdmin;
  69
  70   private final ExecutorService pool;
  71
  72   AsyncHBaseAdmin(RawAsyncHBaseAdmin rawAdmin, ExecutorService pool) {
  73     this.rawAdmin = rawAdmin;
  74     this.pool = pool;
  75   }
  76
  77   private <T> CompletableFuture<T> wrap(CompletableFuture<T> future) {
  78     return FutureUtils.wrapFuture(future, pool);
  79   }
  80
  81   @Override
  82   public CompletableFuture<Boolean> tableExists(TableName tableName) {
  83     return wrap(rawAdmin.tableExists(tableName));
  84   }
  85
  86   @Override
  87   public CompletableFuture<List<TableDescriptor>> listTableDescriptors(boolean includeSysTables) {
  88     return wrap(rawAdmin.listTableDescriptors(includeSysTables));
  89   }
  90
  91   @Override
  92   public CompletableFuture<List<TableDescriptor>> listTableDescriptors(Pattern pattern,
  93       boolean includeSysTables) {
  94     return wrap(rawAdmin.listTableDescriptors(pattern, includeSysTables));
  95   }
  96
  97   @Override
  98   public CompletableFuture<List<TableDescriptor>> listTableDescriptors(List<TableName> tableNames) {
  99     return wrap(rawAdmin.listTableDescriptors(tableNames));
 100   }
 101
 102   @Override
 103   public CompletableFuture<List<TableDescriptor>> listTableDescriptorsByNamespace(String name) {
 104     return wrap(rawAdmin.listTableDescriptorsByNamespace(name));
 105   }
 106
 107   @Override
 108   public CompletableFuture<List<TableName>> listTableNames(boolean includeSysTables) {
 109     return wrap(rawAdmin.listTableNames(includeSysTables));
 110   }
 111
 112   @Override
 113   public CompletableFuture<List<TableName>> listTableNames(Pattern pattern,
 114       boolean includeSysTables) {
 115     return wrap(rawAdmin.listTableNames(pattern, includeSysTables));
 116   }
 117
 118   @Override
 119   public CompletableFuture<List<TableName>> listTableNamesByNamespace(String name) {
 120     return wrap(rawAdmin.listTableNamesByNamespace(name));
 121   }
 122
 123   @Override
 124   public CompletableFuture<TableDescriptor> getDescriptor(TableName tableName) {
 125     return wrap(rawAdmin.getDescriptor(tableName));
 126   }
 127
 128   @Override
 129   public CompletableFuture<Void> createTable(TableDescriptor desc) {
 130     return wrap(rawAdmin.createTable(desc));
 131   }
 132
 133   @Override
 134   public CompletableFuture<Void> createTable(TableDescriptor desc, byte[] startKey, byte[] endKey,
 135       int numRegions) {
 136     return wrap(rawAdmin.createTable(desc, startKey, endKey, numRegions));
 137   }
 138
 139   @Override
 140   public CompletableFuture<Void> createTable(TableDescriptor desc, byte[][] splitKeys) {
 141     return wrap(rawAdmin.createTable(desc, splitKeys));
 142   }
 143
 144   @Override
 145   public CompletableFuture<Void> modifyTable(TableDescriptor desc) {
 146     return wrap(rawAdmin.modifyTable(desc));
 147   }
 148
 149   @Override
 150   public CompletableFuture<Void> modifyTableStoreFileTracker(TableName tableName, String dstSFT) {
 151     return wrap(rawAdmin.modifyTableStoreFileTracker(tableName, dstSFT));
 152   }
 153
 154   @Override
 155   public CompletableFuture<Void> deleteTable(TableName tableName) {
 156     return wrap(rawAdmin.deleteTable(tableName));
 157   }
 158
 159   @Override
 160   public CompletableFuture<Void> truncateTable(TableName tableName, boolean preserveSplits) {
 161     return wrap(rawAdmin.truncateTable(tableName, preserveSplits));
 162   }
 163
 164   @Override
 165   public CompletableFuture<Void> enableTable(TableName tableName) {
 166     return wrap(rawAdmin.enableTable(tableName));
 167   }
 168
 169   @Override
 170   public CompletableFuture<Void> disableTable(TableName tableName) {
 171     return wrap(rawAdmin.disableTable(tableName));
 172   }
 173
 174   @Override
 175   public CompletableFuture<Boolean> isTableEnabled(TableName tableName) {
 176     return wrap(rawAdmin.isTableEnabled(tableName));
 177   }
 178
 179   @Override
 180   public CompletableFuture<Boolean> isTableDisabled(TableName tableName) {
 181     return wrap(rawAdmin.isTableDisabled(tableName));
 182   }
 183
 184   @Override
 185   public CompletableFuture<Boolean> isTableAvailable(TableName tableName) {
 186     return wrap(rawAdmin.isTableAvailable(tableName));
 187   }
 188
 189   @Override
 190   public CompletableFuture<Void> addColumnFamily(TableName tableName,
 191       ColumnFamilyDescriptor columnFamily) {
 192     return wrap(rawAdmin.addColumnFamily(tableName, columnFamily));
 193   }
 194
 195   @Override
 196   public CompletableFuture<Void> deleteColumnFamily(TableName tableName, byte[] columnFamily) {
 197     return wrap(rawAdmin.deleteColumnFamily(tableName, columnFamily));
 198   }
 199
 200   @Override
 201   public CompletableFuture<Void> modifyColumnFamily(TableName tableName,
 202       ColumnFamilyDescriptor columnFamily) {
 203     return wrap(rawAdmin.modifyColumnFamily(tableName, columnFamily));
 204   }
 205
 206   @Override
 207   public CompletableFuture<Void> modifyColumnFamilyStoreFileTracker(TableName tableName,
 208     byte[] family, String dstSFT) {
 209     return wrap(rawAdmin.modifyColumnFamilyStoreFileTracker(tableName, family, dstSFT));
 210   }
 211
 212   @Override
 213   public CompletableFuture<Void> createNamespace(NamespaceDescriptor descriptor) {
 214     return wrap(rawAdmin.createNamespace(descriptor));
 215   }
 216
 217   @Override
 218   public CompletableFuture<Void> modifyNamespace(NamespaceDescriptor descriptor) {
 219     return wrap(rawAdmin.modifyNamespace(descriptor));
 220   }
 221
 222   @Override
 223   public CompletableFuture<Void> deleteNamespace(String name) {
 224     return wrap(rawAdmin.deleteNamespace(name));
 225   }
 226
 227   @Override
 228   public CompletableFuture<NamespaceDescriptor> getNamespaceDescriptor(String name) {
 229     return wrap(rawAdmin.getNamespaceDescriptor(name));
 230   }
 231
 232   @Override
 233   public CompletableFuture<List<String>> listNamespaces() {
 234     return wrap(rawAdmin.listNamespaces());
 235   }
 236
 237   @Override
 238   public CompletableFuture<List<NamespaceDescriptor>> listNamespaceDescriptors() {
 239     return wrap(rawAdmin.listNamespaceDescriptors());
 240   }
 241
 242   @Override
 243   public CompletableFuture<List<RegionInfo>> getRegions(ServerName serverName) {
 244     return wrap(rawAdmin.getRegions(serverName));
 245   }
 246
 247   @Override
 248   public CompletableFuture<List<RegionInfo>> getRegions(TableName tableName) {
 249     return wrap(rawAdmin.getRegions(tableName));
 250   }
 251
 252   @Override
 253   public CompletableFuture<Void> flush(TableName tableName) {
 254     return wrap(rawAdmin.flush(tableName));
 255   }
 256
 257   @Override
 258   public CompletableFuture<Void> flush(TableName tableName, byte[] columnFamily) {
 259     return wrap(rawAdmin.flush(tableName, columnFamily));
 260   }
 261
 262   @Override
 263   public CompletableFuture<Void> flushRegion(byte[] regionName) {
 264     return wrap(rawAdmin.flushRegion(regionName));
 265   }
 266
 267   @Override
 268   public CompletableFuture<Void> flushRegion(byte[] regionName, byte[] columnFamily) {
 269     return wrap(rawAdmin.flushRegion(regionName, columnFamily));
 270   }
 271
 272   @Override
 273   public CompletableFuture<Void> flushRegionServer(ServerName sn) {
 274     return wrap(rawAdmin.flushRegionServer(sn));
 275   }
 276
 277   @Override
 278   public CompletableFuture<Void> compact(TableName tableName,
 279       CompactType compactType) {
 280     return wrap(rawAdmin.compact(tableName, compactType));
 281   }
 282
 283   @Override
 284   public CompletableFuture<Void> compact(TableName tableName,
 285       byte[] columnFamily, CompactType compactType) {
 286     return wrap(rawAdmin.compact(tableName, columnFamily, compactType));
 287   }
 288
 289   @Override
 290   public CompletableFuture<Void> compactRegion(byte[] regionName) {
 291     return wrap(rawAdmin.compactRegion(regionName));
 292   }
 293
 294   @Override
 295   public CompletableFuture<Void> compactRegion(byte[] regionName, byte[] columnFamily) {
 296     return wrap(rawAdmin.compactRegion(regionName, columnFamily));
 297   }
 298
 299   @Override
 300   public CompletableFuture<Void> majorCompact(TableName tableName, CompactType compactType) {
 301     return wrap(rawAdmin.majorCompact(tableName, compactType));
 302   }
 303
 304   @Override
 305   public CompletableFuture<Void> majorCompact(TableName tableName, byte[] columnFamily,
 306       CompactType compactType) {
 307     return wrap(rawAdmin.majorCompact(tableName, columnFamily, compactType));
 308   }
 309
 310   @Override
 311   public CompletableFuture<Void> majorCompactRegion(byte[] regionName) {
 312     return wrap(rawAdmin.majorCompactRegion(regionName));
 313   }
 314
 315   @Override
 316   public CompletableFuture<Void> majorCompactRegion(byte[] regionName, byte[] columnFamily) {
 317     return wrap(rawAdmin.majorCompactRegion(regionName, columnFamily));
 318   }
 319
 320   @Override
 321   public CompletableFuture<Void> compactRegionServer(ServerName serverName) {
 322     return wrap(rawAdmin.compactRegionServer(serverName));
 323   }
 324
 325   @Override
 326   public CompletableFuture<Void> majorCompactRegionServer(ServerName serverName) {
 327     return wrap(rawAdmin.majorCompactRegionServer(serverName));
 328   }
 329
 330   @Override
 331   public CompletableFuture<Boolean> mergeSwitch(boolean enabled, boolean drainMerges) {
 332     return wrap(rawAdmin.mergeSwitch(enabled, drainMerges));
 333   }
 334
 335   @Override
 336   public CompletableFuture<Boolean> isMergeEnabled() {
 337     return wrap(rawAdmin.isMergeEnabled());
 338   }
 339
 340   @Override
 341   public CompletableFuture<Boolean> splitSwitch(boolean enabled, boolean drainSplits) {
 342     return wrap(rawAdmin.splitSwitch(enabled, drainSplits));
 343   }
 344
 345   @Override
 346   public CompletableFuture<Boolean> isSplitEnabled() {
 347     return wrap(rawAdmin.isSplitEnabled());
 348   }
 349
 350   @Override
 351   public CompletableFuture<Void> mergeRegions(List<byte[]> nameOfRegionsToMerge, boolean forcible) {
 352     return wrap(rawAdmin.mergeRegions(nameOfRegionsToMerge, forcible));
 353   }
 354
 355   @Override
 356   public CompletableFuture<Void> split(TableName tableName) {
 357     return wrap(rawAdmin.split(tableName));
 358   }
 359
 360   @Override
 361   public CompletableFuture<Void> split(TableName tableName, byte[] splitPoint) {
 362     return wrap(rawAdmin.split(tableName, splitPoint));
 363   }
 364
 365   @Override
 366   public CompletableFuture<Void> splitRegion(byte[] regionName) {
 367     return wrap(rawAdmin.splitRegion(regionName));
 368   }
 369
 370   @Override
 371   public CompletableFuture<Void> splitRegion(byte[] regionName, byte[] splitPoint) {
 372     return wrap(rawAdmin.splitRegion(regionName, splitPoint));
 373   }
 374
 375   @Override
 376   public CompletableFuture<Void> assign(byte[] regionName) {
 377     return wrap(rawAdmin.assign(regionName));
 378   }
 379
 380   @Override
 381   public CompletableFuture<Void> unassign(byte[] regionName) {
 382     return wrap(rawAdmin.unassign(regionName));
 383   }
 384
 385   @Override
 386   public CompletableFuture<Void> offline(byte[] regionName) {
 387     return wrap(rawAdmin.offline(regionName));
 388   }
 389
 390   @Override
 391   public CompletableFuture<Void> move(byte[] regionName) {
 392     return wrap(rawAdmin.move(regionName));
 393   }
 394
 395   @Override
 396   public CompletableFuture<Void> move(byte[] regionName, ServerName destServerName) {
 397     return wrap(rawAdmin.move(regionName, destServerName));
 398   }
 399
 400   @Override
 401   public CompletableFuture<Void> setQuota(QuotaSettings quota) {
 402     return wrap(rawAdmin.setQuota(quota));
 403   }
 404
 405   @Override
 406   public CompletableFuture<List<QuotaSettings>> getQuota(QuotaFilter filter) {
 407     return wrap(rawAdmin.getQuota(filter));
 408   }
 409
 410   @Override
 411   public CompletableFuture<Void> addReplicationPeer(String peerId,
 412       ReplicationPeerConfig peerConfig, boolean enabled) {
 413     return wrap(rawAdmin.addReplicationPeer(peerId, peerConfig, enabled));
 414   }
 415
 416   @Override
 417   public CompletableFuture<Void> removeReplicationPeer(String peerId) {
 418     return wrap(rawAdmin.removeReplicationPeer(peerId));
 419   }
 420
 421   @Override
 422   public CompletableFuture<Void> enableReplicationPeer(String peerId) {
 423     return wrap(rawAdmin.enableReplicationPeer(peerId));
 424   }
 425
 426   @Override
 427   public CompletableFuture<Void> disableReplicationPeer(String peerId) {
 428     return wrap(rawAdmin.disableReplicationPeer(peerId));
 429   }
 430
 431   @Override
 432   public CompletableFuture<ReplicationPeerConfig> getReplicationPeerConfig(String peerId) {
 433     return wrap(rawAdmin.getReplicationPeerConfig(peerId));
 434   }
 435
 436   @Override
 437   public CompletableFuture<Void> updateReplicationPeerConfig(String peerId,
 438       ReplicationPeerConfig peerConfig) {
 439     return wrap(rawAdmin.updateReplicationPeerConfig(peerId, peerConfig));
 440   }
 441
 442   @Override
 443   public CompletableFuture<Void> transitReplicationPeerSyncReplicationState(String peerId,
 444       SyncReplicationState clusterState) {
 445     return wrap(rawAdmin.transitReplicationPeerSyncReplicationState(peerId, clusterState));
 446   }
 447
 448   @Override
 449   public CompletableFuture<Void> appendReplicationPeerTableCFs(String peerId,
 450       Map<TableName, List<String>> tableCfs) {
 451     return wrap(rawAdmin.appendReplicationPeerTableCFs(peerId, tableCfs));
 452   }
 453
 454   @Override
 455   public CompletableFuture<Void> removeReplicationPeerTableCFs(String peerId,
 456       Map<TableName, List<String>> tableCfs) {
 457     return wrap(rawAdmin.removeReplicationPeerTableCFs(peerId, tableCfs));
 458   }
 459
 460   @Override
 461   public CompletableFuture<List<ReplicationPeerDescription>> listReplicationPeers() {
 462     return wrap(rawAdmin.listReplicationPeers());
 463   }
 464
 465   @Override
 466   public CompletableFuture<List<ReplicationPeerDescription>> listReplicationPeers(Pattern pattern) {
 467     return wrap(rawAdmin.listReplicationPeers(pattern));
 468   }
 469
 470   @Override
 471   public CompletableFuture<List<TableCFs>> listReplicatedTableCFs() {
 472     return wrap(rawAdmin.listReplicatedTableCFs());
 473   }
 474
 475   @Override
 476   public CompletableFuture<Void> enableTableReplication(TableName tableName) {
 477     return wrap(rawAdmin.enableTableReplication(tableName));
 478   }
 479
 480   @Override
 481   public CompletableFuture<Void> disableTableReplication(TableName tableName) {
 482     return wrap(rawAdmin.disableTableReplication(tableName));
 483   }
 484
 485   @Override
 486   public CompletableFuture<Void> snapshot(SnapshotDescription snapshot) {
 487     return wrap(rawAdmin.snapshot(snapshot));
 488   }
 489
 490   @Override
 491   public CompletableFuture<Boolean> isSnapshotFinished(SnapshotDescription snapshot) {
 492     return wrap(rawAdmin.isSnapshotFinished(snapshot));
 493   }
 494
 495   @Override
 496   public CompletableFuture<Void> restoreSnapshot(String snapshotName) {
 497     return wrap(rawAdmin.restoreSnapshot(snapshotName));
 498   }
 499
 500   @Override
 501   public CompletableFuture<Void> restoreSnapshot(String snapshotName, boolean takeFailSafeSnapshot,
 502     boolean restoreAcl) {
 503     return wrap(rawAdmin.restoreSnapshot(snapshotName, takeFailSafeSnapshot, restoreAcl));
 504   }
 505
 506   @Override
 507   public CompletableFuture<Void> cloneSnapshot(String snapshotName, TableName tableName,
 508       boolean restoreAcl, String customSFT) {
 509     return wrap(rawAdmin.cloneSnapshot(snapshotName, tableName, restoreAcl, customSFT));
 510   }
 511
 512   @Override
 513   public CompletableFuture<List<SnapshotDescription>> listSnapshots() {
 514     return wrap(rawAdmin.listSnapshots());
 515   }
 516
 517   @Override
 518   public CompletableFuture<List<SnapshotDescription>> listSnapshots(Pattern pattern) {
 519     return wrap(rawAdmin.listSnapshots(pattern));
 520   }
 521
 522   @Override
 523   public CompletableFuture<List<SnapshotDescription>> listTableSnapshots(Pattern tableNamePattern) {
 524     return wrap(rawAdmin.listTableSnapshots(tableNamePattern));
 525   }
 526
 527   @Override
 528   public CompletableFuture<List<SnapshotDescription>> listTableSnapshots(Pattern tableNamePattern,
 529       Pattern snapshotNamePattern) {
 530     return wrap(rawAdmin.listTableSnapshots(tableNamePattern, snapshotNamePattern));
 531   }
 532
 533   @Override
 534   public CompletableFuture<Void> deleteSnapshot(String snapshotName) {
 535     return wrap(rawAdmin.deleteSnapshot(snapshotName));
 536   }
 537
 538   @Override
 539   public CompletableFuture<Void> deleteSnapshots() {
 540     return wrap(rawAdmin.deleteSnapshots());
 541   }
 542
 543   @Override
 544   public CompletableFuture<Void> deleteSnapshots(Pattern pattern) {
 545     return wrap(rawAdmin.deleteSnapshots(pattern));
 546   }
 547
 548   @Override
 549   public CompletableFuture<Void> deleteTableSnapshots(Pattern tableNamePattern) {
 550     return wrap(rawAdmin.deleteTableSnapshots(tableNamePattern));
 551   }
 552
 553   @Override
 554   public CompletableFuture<Void> deleteTableSnapshots(Pattern tableNamePattern,
 555       Pattern snapshotNamePattern) {
 556     return wrap(rawAdmin.deleteTableSnapshots(tableNamePattern, snapshotNamePattern));
 557   }
 558
 559   @Override
 560   public CompletableFuture<Void> execProcedure(String signature, String instance,
 561       Map<String, String> props) {
 562     return wrap(rawAdmin.execProcedure(signature, instance, props));
 563   }
 564
 565   @Override
 566   public CompletableFuture<byte[]> execProcedureWithReturn(String signature, String instance,
 567       Map<String, String> props) {
 568     return wrap(rawAdmin.execProcedureWithReturn(signature, instance, props));
 569   }
 570
 571   @Override
 572   public CompletableFuture<Boolean> isProcedureFinished(String signature, String instance,
 573       Map<String, String> props) {
 574     return wrap(rawAdmin.isProcedureFinished(signature, instance, props));
 575   }
 576
 577   @Override
 578   public CompletableFuture<Boolean> abortProcedure(long procId, boolean mayInterruptIfRunning) {
 579     return wrap(rawAdmin.abortProcedure(procId, mayInterruptIfRunning));
 580   }
 581
 582   @Override
 583   public CompletableFuture<String> getProcedures() {
 584     return wrap(rawAdmin.getProcedures());
 585   }
 586
 587   @Override
 588   public CompletableFuture<String> getLocks() {
 589     return wrap(rawAdmin.getLocks());
 590   }
 591
 592   @Override
 593   public CompletableFuture<Void> decommissionRegionServers(List<ServerName> servers,
 594       boolean offload) {
 595     return wrap(rawAdmin.decommissionRegionServers(servers, offload));
 596   }
 597
 598   @Override
 599   public CompletableFuture<List<ServerName>> listDecommissionedRegionServers() {
 600     return wrap(rawAdmin.listDecommissionedRegionServers());
 601   }
 602
 603   @Override
 604   public CompletableFuture<Void> recommissionRegionServer(ServerName server,
 605       List<byte[]> encodedRegionNames) {
 606     return wrap(rawAdmin.recommissionRegionServer(server, encodedRegionNames));
 607   }
 608
 609   @Override
 610   public CompletableFuture<ClusterMetrics> getClusterMetrics() {
 611     return getClusterMetrics(EnumSet.allOf(Option.class));
 612   }
 613
 614   @Override
 615   public CompletableFuture<ClusterMetrics> getClusterMetrics(EnumSet<Option> options) {
 616     return wrap(rawAdmin.getClusterMetrics(options));
 617   }
 618
 619   @Override
 620   public CompletableFuture<Void> shutdown() {
 621     return wrap(rawAdmin.shutdown());
 622   }
 623
 624   @Override
 625   public CompletableFuture<Void> stopMaster() {
 626     return wrap(rawAdmin.stopMaster());
 627   }
 628
 629   @Override
 630   public CompletableFuture<Void> stopRegionServer(ServerName serverName) {
 631     return wrap(rawAdmin.stopRegionServer(serverName));
 632   }
 633
 634   @Override
 635   public CompletableFuture<Void> updateConfiguration(ServerName serverName) {
 636     return wrap(rawAdmin.updateConfiguration(serverName));
 637   }
 638
 639   @Override
 640   public CompletableFuture<Void> updateConfiguration() {
 641     return wrap(rawAdmin.updateConfiguration());
 642   }
 643
 644   @Override
 645   public CompletableFuture<Void> updateConfiguration(String groupName) {
 646     return wrap(rawAdmin.updateConfiguration(groupName));
 647   }
 648
 649   @Override
 650   public CompletableFuture<Void> rollWALWriter(ServerName serverName) {
 651     return wrap(rawAdmin.rollWALWriter(serverName));
 652   }
 653
 654   @Override
 655   public CompletableFuture<Void> clearCompactionQueues(ServerName serverName, Set<String> queues) {
 656     return wrap(rawAdmin.clearCompactionQueues(serverName, queues));
 657   }
 658
 659   @Override
 660   public CompletableFuture<List<SecurityCapability>> getSecurityCapabilities() {
 661     return wrap(rawAdmin.getSecurityCapabilities());
 662   }
 663
 664   @Override
 665   public CompletableFuture<List<RegionMetrics>> getRegionMetrics(ServerName serverName) {
 666     return wrap(rawAdmin.getRegionMetrics(serverName));
 667   }
 668
 669   @Override
 670   public CompletableFuture<List<RegionMetrics>> getRegionMetrics(ServerName serverName,
 671       TableName tableName) {
 672     return wrap(rawAdmin.getRegionMetrics(serverName, tableName));
 673   }
 674
 675   @Override
 676   public CompletableFuture<Boolean> isMasterInMaintenanceMode() {
 677     return wrap(rawAdmin.isMasterInMaintenanceMode());
 678   }
 679
 680   @Override
 681   public CompletableFuture<CompactionState> getCompactionState(
 682       TableName tableName, CompactType compactType) {
 683     return wrap(rawAdmin.getCompactionState(tableName, compactType));
 684   }
 685
 686   @Override
 687   public CompletableFuture<CompactionState> getCompactionStateForRegion(byte[] regionName) {
 688     return wrap(rawAdmin.getCompactionStateForRegion(regionName));
 689   }
 690
 691   @Override
 692   public CompletableFuture<Optional<Long>> getLastMajorCompactionTimestamp(TableName tableName) {
 693     return wrap(rawAdmin.getLastMajorCompactionTimestamp(tableName));
 694   }
 695
 696   @Override
 697   public CompletableFuture<Optional<Long>> getLastMajorCompactionTimestampForRegion(
 698       byte[] regionName) {
 699     return wrap(rawAdmin.getLastMajorCompactionTimestampForRegion(regionName));
 700   }
 701
 702   @Override
 703   public CompletableFuture<Boolean> balancerSwitch(boolean on, boolean drainRITs) {
 704     return wrap(rawAdmin.balancerSwitch(on, drainRITs));
 705   }
 706
 707   @Override
 708   public CompletableFuture<BalanceResponse> balance(BalanceRequest request) {
 709     return wrap(rawAdmin.balance(request));
 710   }
 711
 712   @Override
 713   public CompletableFuture<Boolean> isBalancerEnabled() {
 714     return wrap(rawAdmin.isBalancerEnabled());
 715   }
 716
 717   @Override
 718   public CompletableFuture<Boolean> normalizerSwitch(boolean on) {
 719     return wrap(rawAdmin.normalizerSwitch(on));
 720   }
 721
 722   @Override
 723   public CompletableFuture<Boolean> isNormalizerEnabled() {
 724     return wrap(rawAdmin.isNormalizerEnabled());
 725   }
 726
 727   @Override
 728   public CompletableFuture<Boolean> normalize(NormalizeTableFilterParams ntfp) {
 729     return wrap(rawAdmin.normalize(ntfp));
 730   }
 731
 732   @Override
 733   public CompletableFuture<Boolean> cleanerChoreSwitch(boolean enabled) {
 734     return wrap(rawAdmin.cleanerChoreSwitch(enabled));
 735   }
 736
 737   @Override
 738   public CompletableFuture<Boolean> isCleanerChoreEnabled() {
 739     return wrap(rawAdmin.isCleanerChoreEnabled());
 740   }
 741
 742   @Override
 743   public CompletableFuture<Boolean> runCleanerChore() {
 744     return wrap(rawAdmin.runCleanerChore());
 745   }
 746
 747   @Override
 748   public CompletableFuture<Boolean> catalogJanitorSwitch(boolean enabled) {
 749     return wrap(rawAdmin.catalogJanitorSwitch(enabled));
 750   }
 751
 752   @Override
 753   public CompletableFuture<Boolean> isCatalogJanitorEnabled() {
 754     return wrap(rawAdmin.isCatalogJanitorEnabled());
 755   }
 756
 757   @Override
 758   public CompletableFuture<Integer> runCatalogJanitor() {
 759     return wrap(rawAdmin.runCatalogJanitor());
 760   }
 761
 762   @Override
 763   public <S, R> CompletableFuture<R> coprocessorService(Function<RpcChannel, S> stubMaker,
 764       ServiceCaller<S, R> callable) {
 765     return wrap(rawAdmin.coprocessorService(stubMaker, callable));
 766   }
 767
 768   @Override
 769   public <S, R> CompletableFuture<R> coprocessorService(Function<RpcChannel, S> stubMaker,
 770       ServiceCaller<S, R> callable, ServerName serverName) {
 771     return wrap(rawAdmin.coprocessorService(stubMaker, callable, serverName));
 772   }
 773
 774   @Override
 775   public CompletableFuture<List<ServerName>> listDeadServers() {
 776     return wrap(rawAdmin.listDeadServers());
 777   }
 778
 779   @Override
 780   public CompletableFuture<List<ServerName>> clearDeadServers(List<ServerName> servers) {
 781     return wrap(rawAdmin.clearDeadServers(servers));
 782   }
 783
 784   @Override
 785   public CompletableFuture<CacheEvictionStats> clearBlockCache(TableName tableName) {
 786     return wrap(rawAdmin.clearBlockCache(tableName));
 787   }
 788
 789   @Override
 790   public CompletableFuture<Void> cloneTableSchema(TableName tableName, TableName newTableName,
 791       boolean preserveSplits) {
 792     return wrap(rawAdmin.cloneTableSchema(tableName, newTableName, preserveSplits));
 793   }
 794
 795   @Override
 796   public CompletableFuture<Map<ServerName, Boolean>> compactionSwitch(boolean switchState,
 797       List<String> serverNamesList) {
 798     return wrap(rawAdmin.compactionSwitch(switchState, serverNamesList));
 799   }
 800
 801   @Override
 802   public CompletableFuture<Boolean> switchRpcThrottle(boolean enable) {
 803     return wrap(rawAdmin.switchRpcThrottle(enable));
 804   }
 805
 806   @Override
 807   public CompletableFuture<Boolean> isRpcThrottleEnabled() {
 808     return wrap(rawAdmin.isRpcThrottleEnabled());
 809   }
 810
 811   @Override
 812   public CompletableFuture<Boolean> exceedThrottleQuotaSwitch(boolean enable) {
 813     return wrap(rawAdmin.exceedThrottleQuotaSwitch(enable));
 814   }
 815
 816   @Override
 817   public CompletableFuture<Map<TableName, Long>> getSpaceQuotaTableSizes() {
 818     return wrap(rawAdmin.getSpaceQuotaTableSizes());
 819   }
 820
 821   @Override
 822   public CompletableFuture<Map<TableName, SpaceQuotaSnapshot>> getRegionServerSpaceQuotaSnapshots(
 823       ServerName serverName) {
 824     return wrap(rawAdmin.getRegionServerSpaceQuotaSnapshots(serverName));
 825   }
 826
 827   @Override
 828   public CompletableFuture<SpaceQuotaSnapshot> getCurrentSpaceQuotaSnapshot(String namespace) {
 829     return wrap(rawAdmin.getCurrentSpaceQuotaSnapshot(namespace));
 830   }
 831
 832   @Override
 833   public CompletableFuture<SpaceQuotaSnapshot> getCurrentSpaceQuotaSnapshot(TableName tableName) {
 834     return wrap(rawAdmin.getCurrentSpaceQuotaSnapshot(tableName));
 835   }
 836
 837   @Override
 838   public CompletableFuture<Void> grant(UserPermission userPermission,
 839       boolean mergeExistingPermissions) {
 840     return wrap(rawAdmin.grant(userPermission, mergeExistingPermissions));
 841   }
 842
 843   @Override
 844   public CompletableFuture<Void> revoke(UserPermission userPermission) {
 845     return wrap(rawAdmin.revoke(userPermission));
 846   }
 847
 848   @Override
 849   public CompletableFuture<List<UserPermission>>
 850       getUserPermissions(GetUserPermissionsRequest getUserPermissionsRequest) {
 851     return wrap(rawAdmin.getUserPermissions(getUserPermissionsRequest));
 852   }
 853
 854   @Override
 855   public CompletableFuture<List<Boolean>> hasUserPermissions(String userName,
 856       List<Permission> permissions) {
 857     return wrap(rawAdmin.hasUserPermissions(userName, permissions));
 858   }
 859
 860   @Override
 861   public CompletableFuture<Boolean> snapshotCleanupSwitch(final boolean on,
 862       final boolean sync) {
 863     return wrap(rawAdmin.snapshotCleanupSwitch(on, sync));
 864   }
 865
 866   @Override
 867   public CompletableFuture<Boolean> isSnapshotCleanupEnabled() {
 868     return wrap(rawAdmin.isSnapshotCleanupEnabled());
 869   }
 870
 871   @Override
 872   public CompletableFuture<List<Boolean>> clearSlowLogResponses(Set<ServerName> serverNames) {
 873     return wrap(rawAdmin.clearSlowLogResponses(serverNames));
 874   }
 875
 876   @Override
 877   public CompletableFuture<RSGroupInfo> getRSGroup(String groupName) {
 878     return wrap(rawAdmin.getRSGroup(groupName));
 879   }
 880
 881   @Override
 882   public CompletableFuture<Void> moveServersToRSGroup(Set<Address> servers, String groupName) {
 883     return wrap(rawAdmin.moveServersToRSGroup(servers, groupName));
 884   }
 885
 886   @Override
 887   public CompletableFuture<Void> addRSGroup(String groupName) {
 888     return wrap(rawAdmin.addRSGroup(groupName));
 889   }
 890
 891   @Override
 892   public CompletableFuture<Void> removeRSGroup(String groupName) {
 893     return wrap(rawAdmin.removeRSGroup(groupName));
 894   }
 895
 896   @Override
 897   public CompletableFuture<BalanceResponse> balanceRSGroup(String groupName, BalanceRequest request) {
 898     return wrap(rawAdmin.balanceRSGroup(groupName, request));
 899   }
 900
 901   @Override
 902   public CompletableFuture<List<RSGroupInfo>> listRSGroups() {
 903     return wrap(rawAdmin.listRSGroups());
 904   }
 905
 906   @Override
 907   public CompletableFuture<List<TableName>> listTablesInRSGroup(String groupName) {
 908     return wrap(rawAdmin.listTablesInRSGroup(groupName));
 909   }
 910
 911   @Override
 912   public CompletableFuture<Pair<List<String>, List<TableName>>>
 913     getConfiguredNamespacesAndTablesInRSGroup(String groupName) {
 914     return wrap(rawAdmin.getConfiguredNamespacesAndTablesInRSGroup(groupName));
 915   }
 916
 917   @Override
 918   public CompletableFuture<RSGroupInfo> getRSGroup(Address hostPort) {
 919     return wrap(rawAdmin.getRSGroup(hostPort));
 920   }
 921
 922   @Override
 923   public CompletableFuture<Void> removeServersFromRSGroup(Set<Address> servers) {
 924     return wrap(rawAdmin.removeServersFromRSGroup(servers));
 925   }
 926
 927   @Override
 928   public CompletableFuture<RSGroupInfo> getRSGroup(TableName tableName) {
 929     return wrap(rawAdmin.getRSGroup(tableName));
 930   }
 931
 932   @Override
 933   public CompletableFuture<Void> setRSGroup(Set<TableName> tables, String groupName) {
 934     return wrap(rawAdmin.setRSGroup(tables, groupName));
 935   }
 936
 937   @Override
 938   public CompletableFuture<Void> renameRSGroup(String oldName, String newName) {
 939     return wrap(rawAdmin.renameRSGroup(oldName, newName));
 940   }
 941
 942   @Override
 943   public CompletableFuture<Void>
 944     updateRSGroupConfig(String groupName, Map<String, String> configuration) {
 945     return wrap(rawAdmin.updateRSGroupConfig(groupName, configuration));
 946   }
 947
 948   @Override
 949   public CompletableFuture<List<LogEntry>> getLogEntries(Set<ServerName> serverNames,
 950       String logType, ServerType serverType, int limit,
 951       Map<String, Object> filterParams) {
 952     return wrap(rawAdmin.getLogEntries(serverNames, logType, serverType, limit, filterParams));
 953   }
 954 }