001/* 002 * Licensed to the Apache Software Foundation (ASF) under one 003 * or more contributor license agreements. See the NOTICE file 004 * distributed with this work for additional information 005 * regarding copyright ownership. The ASF licenses this file 006 * to you under the Apache License, Version 2.0 (the 007 * "License"); you may not use this file except in compliance 008 * with the License. You may obtain a copy of the License at 009 * 010 * http://www.apache.org/licenses/LICENSE-2.0 011 * 012 * Unless required by applicable law or agreed to in writing, software 013 * distributed under the License is distributed on an "AS IS" BASIS, 014 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 015 * See the License for the specific language governing permissions and 016 * limitations under the License. 017 */ 018package org.apache.hadoop.hbase.client; 019 020import com.google.protobuf.RpcChannel; 021 022import java.util.EnumSet; 023import java.util.List; 024import java.util.Map; 025import java.util.Optional; 026import java.util.Set; 027import java.util.concurrent.CompletableFuture; 028import java.util.concurrent.ExecutorService; 029import java.util.function.Function; 030import java.util.regex.Pattern; 031import org.apache.hadoop.hbase.CacheEvictionStats; 032import org.apache.hadoop.hbase.ClusterMetrics; 033import org.apache.hadoop.hbase.ClusterMetrics.Option; 034import org.apache.hadoop.hbase.NamespaceDescriptor; 035import org.apache.hadoop.hbase.RegionMetrics; 036import org.apache.hadoop.hbase.ServerName; 037import org.apache.hadoop.hbase.TableName; 038import org.apache.hadoop.hbase.client.replication.TableCFs; 039import org.apache.hadoop.hbase.client.security.SecurityCapability; 040import org.apache.hadoop.hbase.quotas.QuotaFilter; 041import org.apache.hadoop.hbase.quotas.QuotaSettings; 042import org.apache.hadoop.hbase.quotas.SpaceQuotaSnapshot; 043import org.apache.hadoop.hbase.replication.ReplicationPeerConfig; 044import org.apache.hadoop.hbase.replication.ReplicationPeerDescription; 045import org.apache.hadoop.hbase.security.access.GetUserPermissionsRequest; 046import org.apache.hadoop.hbase.security.access.Permission; 047import org.apache.hadoop.hbase.security.access.UserPermission; 048import org.apache.hadoop.hbase.util.FutureUtils; 049import org.apache.yetus.audience.InterfaceAudience; 050 051/** 052 * Just a wrapper of {@link RawAsyncHBaseAdmin}. The difference is that users need to provide a 053 * thread pool when constructing this class, and the callback methods registered to the returned 054 * {@link CompletableFuture} will be executed in this thread pool. So usually it is safe for users 055 * to do anything they want in the callbacks without breaking the rpc framework. 056 * @since 2.0.0 057 * @see RawAsyncHBaseAdmin 058 * @see AsyncConnection#getAdmin(ExecutorService) 059 * @see AsyncConnection#getAdminBuilder(ExecutorService) 060 */ 061@InterfaceAudience.Private 062class AsyncHBaseAdmin implements AsyncAdmin { 063 064 private final RawAsyncHBaseAdmin rawAdmin; 065 066 private final ExecutorService pool; 067 068 AsyncHBaseAdmin(RawAsyncHBaseAdmin rawAdmin, ExecutorService pool) { 069 this.rawAdmin = rawAdmin; 070 this.pool = pool; 071 } 072 073 private <T> CompletableFuture<T> wrap(CompletableFuture<T> future) { 074 return FutureUtils.wrapFuture(future, pool); 075 } 076 077 @Override 078 public CompletableFuture<Boolean> tableExists(TableName tableName) { 079 return wrap(rawAdmin.tableExists(tableName)); 080 } 081 082 @Override 083 public CompletableFuture<List<TableDescriptor>> listTableDescriptors(boolean includeSysTables) { 084 return wrap(rawAdmin.listTableDescriptors(includeSysTables)); 085 } 086 087 @Override 088 public CompletableFuture<List<TableDescriptor>> listTableDescriptors(Pattern pattern, 089 boolean includeSysTables) { 090 return wrap(rawAdmin.listTableDescriptors(pattern, includeSysTables)); 091 } 092 093 @Override 094 public CompletableFuture<List<TableDescriptor>> listTableDescriptors(List<TableName> tableNames) { 095 return wrap(rawAdmin.listTableDescriptors(tableNames)); 096 } 097 098 @Override 099 public CompletableFuture<List<TableDescriptor>> listTableDescriptorsByNamespace(String name) { 100 return wrap(rawAdmin.listTableDescriptorsByNamespace(name)); 101 } 102 103 @Override 104 public CompletableFuture<List<TableName>> listTableNames(boolean includeSysTables) { 105 return wrap(rawAdmin.listTableNames(includeSysTables)); 106 } 107 108 @Override 109 public CompletableFuture<List<TableName>> listTableNames(Pattern pattern, 110 boolean includeSysTables) { 111 return wrap(rawAdmin.listTableNames(pattern, includeSysTables)); 112 } 113 114 @Override 115 public CompletableFuture<List<TableName>> listTableNamesByNamespace(String name) { 116 return wrap(rawAdmin.listTableNamesByNamespace(name)); 117 } 118 119 @Override 120 public CompletableFuture<TableDescriptor> getDescriptor(TableName tableName) { 121 return wrap(rawAdmin.getDescriptor(tableName)); 122 } 123 124 @Override 125 public CompletableFuture<Void> createTable(TableDescriptor desc) { 126 return wrap(rawAdmin.createTable(desc)); 127 } 128 129 @Override 130 public CompletableFuture<Void> createTable(TableDescriptor desc, byte[] startKey, byte[] endKey, 131 int numRegions) { 132 return wrap(rawAdmin.createTable(desc, startKey, endKey, numRegions)); 133 } 134 135 @Override 136 public CompletableFuture<Void> createTable(TableDescriptor desc, byte[][] splitKeys) { 137 return wrap(rawAdmin.createTable(desc, splitKeys)); 138 } 139 140 @Override 141 public CompletableFuture<Void> modifyTable(TableDescriptor desc) { 142 return wrap(rawAdmin.modifyTable(desc)); 143 } 144 145 @Override 146 public CompletableFuture<Void> deleteTable(TableName tableName) { 147 return wrap(rawAdmin.deleteTable(tableName)); 148 } 149 150 @Override 151 public CompletableFuture<Void> truncateTable(TableName tableName, boolean preserveSplits) { 152 return wrap(rawAdmin.truncateTable(tableName, preserveSplits)); 153 } 154 155 @Override 156 public CompletableFuture<Void> enableTable(TableName tableName) { 157 return wrap(rawAdmin.enableTable(tableName)); 158 } 159 160 @Override 161 public CompletableFuture<Void> disableTable(TableName tableName) { 162 return wrap(rawAdmin.disableTable(tableName)); 163 } 164 165 @Override 166 public CompletableFuture<Boolean> isTableEnabled(TableName tableName) { 167 return wrap(rawAdmin.isTableEnabled(tableName)); 168 } 169 170 @Override 171 public CompletableFuture<Boolean> isTableDisabled(TableName tableName) { 172 return wrap(rawAdmin.isTableDisabled(tableName)); 173 } 174 175 @Override 176 public CompletableFuture<Boolean> isTableAvailable(TableName tableName) { 177 return wrap(rawAdmin.isTableAvailable(tableName)); 178 } 179 180 @Override 181 public CompletableFuture<Boolean> isTableAvailable(TableName tableName, byte[][] splitKeys) { 182 return wrap(rawAdmin.isTableAvailable(tableName, splitKeys)); 183 } 184 185 @Override 186 public CompletableFuture<Void> addColumnFamily(TableName tableName, 187 ColumnFamilyDescriptor columnFamily) { 188 return wrap(rawAdmin.addColumnFamily(tableName, columnFamily)); 189 } 190 191 @Override 192 public CompletableFuture<Void> deleteColumnFamily(TableName tableName, byte[] columnFamily) { 193 return wrap(rawAdmin.deleteColumnFamily(tableName, columnFamily)); 194 } 195 196 @Override 197 public CompletableFuture<Void> modifyColumnFamily(TableName tableName, 198 ColumnFamilyDescriptor columnFamily) { 199 return wrap(rawAdmin.modifyColumnFamily(tableName, columnFamily)); 200 } 201 202 @Override 203 public CompletableFuture<Void> createNamespace(NamespaceDescriptor descriptor) { 204 return wrap(rawAdmin.createNamespace(descriptor)); 205 } 206 207 @Override 208 public CompletableFuture<Void> modifyNamespace(NamespaceDescriptor descriptor) { 209 return wrap(rawAdmin.modifyNamespace(descriptor)); 210 } 211 212 @Override 213 public CompletableFuture<Void> deleteNamespace(String name) { 214 return wrap(rawAdmin.deleteNamespace(name)); 215 } 216 217 @Override 218 public CompletableFuture<NamespaceDescriptor> getNamespaceDescriptor(String name) { 219 return wrap(rawAdmin.getNamespaceDescriptor(name)); 220 } 221 222 @Override 223 public CompletableFuture<List<String>> listNamespaces() { 224 return wrap(rawAdmin.listNamespaces()); 225 } 226 227 @Override 228 public CompletableFuture<List<NamespaceDescriptor>> listNamespaceDescriptors() { 229 return wrap(rawAdmin.listNamespaceDescriptors()); 230 } 231 232 @Override 233 public CompletableFuture<List<RegionInfo>> getRegions(ServerName serverName) { 234 return wrap(rawAdmin.getRegions(serverName)); 235 } 236 237 @Override 238 public CompletableFuture<List<RegionInfo>> getRegions(TableName tableName) { 239 return wrap(rawAdmin.getRegions(tableName)); 240 } 241 242 @Override 243 public CompletableFuture<Void> flush(TableName tableName) { 244 return wrap(rawAdmin.flush(tableName)); 245 } 246 247 @Override 248 public CompletableFuture<Void> flush(TableName tableName, byte[] columnFamily) { 249 return wrap(rawAdmin.flush(tableName, columnFamily)); 250 } 251 252 @Override 253 public CompletableFuture<Void> flushRegion(byte[] regionName) { 254 return wrap(rawAdmin.flushRegion(regionName)); 255 } 256 257 @Override 258 public CompletableFuture<Void> flushRegion(byte[] regionName, byte[] columnFamily) { 259 return wrap(rawAdmin.flushRegion(regionName, columnFamily)); 260 } 261 262 @Override 263 public CompletableFuture<Void> flushRegionServer(ServerName sn) { 264 return wrap(rawAdmin.flushRegionServer(sn)); 265 } 266 267 @Override 268 public CompletableFuture<Void> compact(TableName tableName, 269 CompactType compactType) { 270 return wrap(rawAdmin.compact(tableName, compactType)); 271 } 272 273 @Override 274 public CompletableFuture<Void> compact(TableName tableName, 275 byte[] columnFamily, CompactType compactType) { 276 return wrap(rawAdmin.compact(tableName, columnFamily, compactType)); 277 } 278 279 @Override 280 public CompletableFuture<Void> compactRegion(byte[] regionName) { 281 return wrap(rawAdmin.compactRegion(regionName)); 282 } 283 284 @Override 285 public CompletableFuture<Void> compactRegion(byte[] regionName, byte[] columnFamily) { 286 return wrap(rawAdmin.compactRegion(regionName, columnFamily)); 287 } 288 289 @Override 290 public CompletableFuture<Void> majorCompact(TableName tableName, CompactType compactType) { 291 return wrap(rawAdmin.majorCompact(tableName, compactType)); 292 } 293 294 @Override 295 public CompletableFuture<Void> majorCompact(TableName tableName, byte[] columnFamily, 296 CompactType compactType) { 297 return wrap(rawAdmin.majorCompact(tableName, columnFamily, compactType)); 298 } 299 300 @Override 301 public CompletableFuture<Void> majorCompactRegion(byte[] regionName) { 302 return wrap(rawAdmin.majorCompactRegion(regionName)); 303 } 304 305 @Override 306 public CompletableFuture<Void> majorCompactRegion(byte[] regionName, byte[] columnFamily) { 307 return wrap(rawAdmin.majorCompactRegion(regionName, columnFamily)); 308 } 309 310 @Override 311 public CompletableFuture<Void> compactRegionServer(ServerName serverName) { 312 return wrap(rawAdmin.compactRegionServer(serverName)); 313 } 314 315 @Override 316 public CompletableFuture<Void> majorCompactRegionServer(ServerName serverName) { 317 return wrap(rawAdmin.majorCompactRegionServer(serverName)); 318 } 319 320 @Override 321 public CompletableFuture<Boolean> mergeSwitch(boolean enabled, boolean drainMerges) { 322 return wrap(rawAdmin.mergeSwitch(enabled, drainMerges)); 323 } 324 325 @Override 326 public CompletableFuture<Boolean> isMergeEnabled() { 327 return wrap(rawAdmin.isMergeEnabled()); 328 } 329 330 @Override 331 public CompletableFuture<Boolean> splitSwitch(boolean enabled, boolean drainSplits) { 332 return wrap(rawAdmin.splitSwitch(enabled, drainSplits)); 333 } 334 335 @Override 336 public CompletableFuture<Boolean> isSplitEnabled() { 337 return wrap(rawAdmin.isSplitEnabled()); 338 } 339 340 @Override 341 public CompletableFuture<Void> mergeRegions(List<byte[]> nameOfRegionsToMerge, boolean forcible) { 342 return wrap(rawAdmin.mergeRegions(nameOfRegionsToMerge, forcible)); 343 } 344 345 @Override 346 public CompletableFuture<Void> split(TableName tableName) { 347 return wrap(rawAdmin.split(tableName)); 348 } 349 350 @Override 351 public CompletableFuture<Void> split(TableName tableName, byte[] splitPoint) { 352 return wrap(rawAdmin.split(tableName, splitPoint)); 353 } 354 355 @Override 356 public CompletableFuture<Void> splitRegion(byte[] regionName) { 357 return wrap(rawAdmin.splitRegion(regionName)); 358 } 359 360 @Override 361 public CompletableFuture<Void> splitRegion(byte[] regionName, byte[] splitPoint) { 362 return wrap(rawAdmin.splitRegion(regionName, splitPoint)); 363 } 364 365 @Override 366 public CompletableFuture<Void> assign(byte[] regionName) { 367 return wrap(rawAdmin.assign(regionName)); 368 } 369 370 @Override 371 public CompletableFuture<Void> unassign(byte[] regionName) { 372 return wrap(rawAdmin.unassign(regionName)); 373 } 374 375 @Override 376 public CompletableFuture<Void> offline(byte[] regionName) { 377 return wrap(rawAdmin.offline(regionName)); 378 } 379 380 @Override 381 public CompletableFuture<Void> move(byte[] regionName) { 382 return wrap(rawAdmin.move(regionName)); 383 } 384 385 @Override 386 public CompletableFuture<Void> move(byte[] regionName, ServerName destServerName) { 387 return wrap(rawAdmin.move(regionName, destServerName)); 388 } 389 390 @Override 391 public CompletableFuture<Void> setQuota(QuotaSettings quota) { 392 return wrap(rawAdmin.setQuota(quota)); 393 } 394 395 @Override 396 public CompletableFuture<List<QuotaSettings>> getQuota(QuotaFilter filter) { 397 return wrap(rawAdmin.getQuota(filter)); 398 } 399 400 @Override 401 public CompletableFuture<Void> addReplicationPeer(String peerId, 402 ReplicationPeerConfig peerConfig, boolean enabled) { 403 return wrap(rawAdmin.addReplicationPeer(peerId, peerConfig, enabled)); 404 } 405 406 @Override 407 public CompletableFuture<Void> removeReplicationPeer(String peerId) { 408 return wrap(rawAdmin.removeReplicationPeer(peerId)); 409 } 410 411 @Override 412 public CompletableFuture<Void> enableReplicationPeer(String peerId) { 413 return wrap(rawAdmin.enableReplicationPeer(peerId)); 414 } 415 416 @Override 417 public CompletableFuture<Void> disableReplicationPeer(String peerId) { 418 return wrap(rawAdmin.disableReplicationPeer(peerId)); 419 } 420 421 @Override 422 public CompletableFuture<ReplicationPeerConfig> getReplicationPeerConfig(String peerId) { 423 return wrap(rawAdmin.getReplicationPeerConfig(peerId)); 424 } 425 426 @Override 427 public CompletableFuture<Void> updateReplicationPeerConfig(String peerId, 428 ReplicationPeerConfig peerConfig) { 429 return wrap(rawAdmin.updateReplicationPeerConfig(peerId, peerConfig)); 430 } 431 432 @Override 433 public CompletableFuture<Void> appendReplicationPeerTableCFs(String peerId, 434 Map<TableName, List<String>> tableCfs) { 435 return wrap(rawAdmin.appendReplicationPeerTableCFs(peerId, tableCfs)); 436 } 437 438 @Override 439 public CompletableFuture<Void> removeReplicationPeerTableCFs(String peerId, 440 Map<TableName, List<String>> tableCfs) { 441 return wrap(rawAdmin.removeReplicationPeerTableCFs(peerId, tableCfs)); 442 } 443 444 @Override 445 public CompletableFuture<List<ReplicationPeerDescription>> listReplicationPeers() { 446 return wrap(rawAdmin.listReplicationPeers()); 447 } 448 449 @Override 450 public CompletableFuture<List<ReplicationPeerDescription>> listReplicationPeers(Pattern pattern) { 451 return wrap(rawAdmin.listReplicationPeers(pattern)); 452 } 453 454 @Override 455 public CompletableFuture<List<TableCFs>> listReplicatedTableCFs() { 456 return wrap(rawAdmin.listReplicatedTableCFs()); 457 } 458 459 @Override 460 public CompletableFuture<Void> enableTableReplication(TableName tableName) { 461 return wrap(rawAdmin.enableTableReplication(tableName)); 462 } 463 464 @Override 465 public CompletableFuture<Void> disableTableReplication(TableName tableName) { 466 return wrap(rawAdmin.disableTableReplication(tableName)); 467 } 468 469 @Override 470 public CompletableFuture<Void> snapshot(SnapshotDescription snapshot) { 471 return wrap(rawAdmin.snapshot(snapshot)); 472 } 473 474 @Override 475 public CompletableFuture<Boolean> isSnapshotFinished(SnapshotDescription snapshot) { 476 return wrap(rawAdmin.isSnapshotFinished(snapshot)); 477 } 478 479 @Override 480 public CompletableFuture<Void> restoreSnapshot(String snapshotName) { 481 return wrap(rawAdmin.restoreSnapshot(snapshotName)); 482 } 483 484 @Override 485 public CompletableFuture<Void> restoreSnapshot(String snapshotName, boolean takeFailSafeSnapshot, 486 boolean restoreAcl) { 487 return wrap(rawAdmin.restoreSnapshot(snapshotName, takeFailSafeSnapshot, restoreAcl)); 488 } 489 490 @Override 491 public CompletableFuture<Void> cloneSnapshot(String snapshotName, TableName tableName, 492 boolean restoreAcl) { 493 return wrap(rawAdmin.cloneSnapshot(snapshotName, tableName, restoreAcl)); 494 } 495 496 @Override 497 public CompletableFuture<List<SnapshotDescription>> listSnapshots() { 498 return wrap(rawAdmin.listSnapshots()); 499 } 500 501 @Override 502 public CompletableFuture<List<SnapshotDescription>> listSnapshots(Pattern pattern) { 503 return wrap(rawAdmin.listSnapshots(pattern)); 504 } 505 506 @Override 507 public CompletableFuture<List<SnapshotDescription>> listTableSnapshots(Pattern tableNamePattern) { 508 return wrap(rawAdmin.listTableSnapshots(tableNamePattern)); 509 } 510 511 @Override 512 public CompletableFuture<List<SnapshotDescription>> listTableSnapshots(Pattern tableNamePattern, 513 Pattern snapshotNamePattern) { 514 return wrap(rawAdmin.listTableSnapshots(tableNamePattern, snapshotNamePattern)); 515 } 516 517 @Override 518 public CompletableFuture<Void> deleteSnapshot(String snapshotName) { 519 return wrap(rawAdmin.deleteSnapshot(snapshotName)); 520 } 521 522 @Override 523 public CompletableFuture<Void> deleteSnapshots() { 524 return wrap(rawAdmin.deleteSnapshots()); 525 } 526 527 @Override 528 public CompletableFuture<Void> deleteSnapshots(Pattern pattern) { 529 return wrap(rawAdmin.deleteSnapshots(pattern)); 530 } 531 532 @Override 533 public CompletableFuture<Void> deleteTableSnapshots(Pattern tableNamePattern) { 534 return wrap(rawAdmin.deleteTableSnapshots(tableNamePattern)); 535 } 536 537 @Override 538 public CompletableFuture<Void> deleteTableSnapshots(Pattern tableNamePattern, 539 Pattern snapshotNamePattern) { 540 return wrap(rawAdmin.deleteTableSnapshots(tableNamePattern, snapshotNamePattern)); 541 } 542 543 @Override 544 public CompletableFuture<Void> execProcedure(String signature, String instance, 545 Map<String, String> props) { 546 return wrap(rawAdmin.execProcedure(signature, instance, props)); 547 } 548 549 @Override 550 public CompletableFuture<byte[]> execProcedureWithReturn(String signature, String instance, 551 Map<String, String> props) { 552 return wrap(rawAdmin.execProcedureWithReturn(signature, instance, props)); 553 } 554 555 @Override 556 public CompletableFuture<Boolean> isProcedureFinished(String signature, String instance, 557 Map<String, String> props) { 558 return wrap(rawAdmin.isProcedureFinished(signature, instance, props)); 559 } 560 561 @Override 562 public CompletableFuture<Boolean> abortProcedure(long procId, boolean mayInterruptIfRunning) { 563 return wrap(rawAdmin.abortProcedure(procId, mayInterruptIfRunning)); 564 } 565 566 @Override 567 public CompletableFuture<String> getProcedures() { 568 return wrap(rawAdmin.getProcedures()); 569 } 570 571 @Override 572 public CompletableFuture<String> getLocks() { 573 return wrap(rawAdmin.getLocks()); 574 } 575 576 @Override 577 public CompletableFuture<Void> decommissionRegionServers(List<ServerName> servers, 578 boolean offload) { 579 return wrap(rawAdmin.decommissionRegionServers(servers, offload)); 580 } 581 582 @Override 583 public CompletableFuture<List<ServerName>> listDecommissionedRegionServers() { 584 return wrap(rawAdmin.listDecommissionedRegionServers()); 585 } 586 587 @Override 588 public CompletableFuture<Void> recommissionRegionServer(ServerName server, 589 List<byte[]> encodedRegionNames) { 590 return wrap(rawAdmin.recommissionRegionServer(server, encodedRegionNames)); 591 } 592 593 @Override 594 public CompletableFuture<ClusterMetrics> getClusterMetrics() { 595 return getClusterMetrics(EnumSet.allOf(Option.class)); 596 } 597 598 @Override 599 public CompletableFuture<ClusterMetrics> getClusterMetrics(EnumSet<Option> options) { 600 return wrap(rawAdmin.getClusterMetrics(options)); 601 } 602 603 @Override 604 public CompletableFuture<Void> shutdown() { 605 return wrap(rawAdmin.shutdown()); 606 } 607 608 @Override 609 public CompletableFuture<Void> stopMaster() { 610 return wrap(rawAdmin.stopMaster()); 611 } 612 613 @Override 614 public CompletableFuture<Void> stopRegionServer(ServerName serverName) { 615 return wrap(rawAdmin.stopRegionServer(serverName)); 616 } 617 618 @Override 619 public CompletableFuture<Void> updateConfiguration(ServerName serverName) { 620 return wrap(rawAdmin.updateConfiguration(serverName)); 621 } 622 623 @Override 624 public CompletableFuture<Void> updateConfiguration() { 625 return wrap(rawAdmin.updateConfiguration()); 626 } 627 628 @Override 629 public CompletableFuture<Void> rollWALWriter(ServerName serverName) { 630 return wrap(rawAdmin.rollWALWriter(serverName)); 631 } 632 633 @Override 634 public CompletableFuture<Void> clearCompactionQueues(ServerName serverName, Set<String> queues) { 635 return wrap(rawAdmin.clearCompactionQueues(serverName, queues)); 636 } 637 638 @Override 639 public CompletableFuture<List<SecurityCapability>> getSecurityCapabilities() { 640 return wrap(rawAdmin.getSecurityCapabilities()); 641 } 642 643 @Override 644 public CompletableFuture<List<RegionMetrics>> getRegionMetrics(ServerName serverName) { 645 return wrap(rawAdmin.getRegionMetrics(serverName)); 646 } 647 648 @Override 649 public CompletableFuture<List<RegionMetrics>> getRegionMetrics(ServerName serverName, 650 TableName tableName) { 651 return wrap(rawAdmin.getRegionMetrics(serverName, tableName)); 652 } 653 654 @Override 655 public CompletableFuture<Boolean> isMasterInMaintenanceMode() { 656 return wrap(rawAdmin.isMasterInMaintenanceMode()); 657 } 658 659 @Override 660 public CompletableFuture<CompactionState> getCompactionState( 661 TableName tableName, CompactType compactType) { 662 return wrap(rawAdmin.getCompactionState(tableName, compactType)); 663 } 664 665 @Override 666 public CompletableFuture<CompactionState> getCompactionStateForRegion(byte[] regionName) { 667 return wrap(rawAdmin.getCompactionStateForRegion(regionName)); 668 } 669 670 @Override 671 public CompletableFuture<Optional<Long>> getLastMajorCompactionTimestamp(TableName tableName) { 672 return wrap(rawAdmin.getLastMajorCompactionTimestamp(tableName)); 673 } 674 675 @Override 676 public CompletableFuture<Optional<Long>> getLastMajorCompactionTimestampForRegion( 677 byte[] regionName) { 678 return wrap(rawAdmin.getLastMajorCompactionTimestampForRegion(regionName)); 679 } 680 681 @Override 682 public CompletableFuture<Boolean> balancerSwitch(boolean on, boolean drainRITs) { 683 return wrap(rawAdmin.balancerSwitch(on, drainRITs)); 684 } 685 686 @Override 687 public CompletableFuture<Boolean> balance(boolean forcible) { 688 return wrap(rawAdmin.balance(forcible)); 689 } 690 691 @Override 692 public CompletableFuture<Boolean> isBalancerEnabled() { 693 return wrap(rawAdmin.isBalancerEnabled()); 694 } 695 696 @Override 697 public CompletableFuture<Boolean> normalizerSwitch(boolean on) { 698 return wrap(rawAdmin.normalizerSwitch(on)); 699 } 700 701 @Override 702 public CompletableFuture<Boolean> isNormalizerEnabled() { 703 return wrap(rawAdmin.isNormalizerEnabled()); 704 } 705 706 @Override 707 public CompletableFuture<Boolean> normalize(NormalizeTableFilterParams ntfp) { 708 return wrap(rawAdmin.normalize(ntfp)); 709 } 710 711 @Override 712 public CompletableFuture<Boolean> cleanerChoreSwitch(boolean enabled) { 713 return wrap(rawAdmin.cleanerChoreSwitch(enabled)); 714 } 715 716 @Override 717 public CompletableFuture<Boolean> isCleanerChoreEnabled() { 718 return wrap(rawAdmin.isCleanerChoreEnabled()); 719 } 720 721 @Override 722 public CompletableFuture<Boolean> runCleanerChore() { 723 return wrap(rawAdmin.runCleanerChore()); 724 } 725 726 @Override 727 public CompletableFuture<Boolean> catalogJanitorSwitch(boolean enabled) { 728 return wrap(rawAdmin.catalogJanitorSwitch(enabled)); 729 } 730 731 @Override 732 public CompletableFuture<Boolean> isCatalogJanitorEnabled() { 733 return wrap(rawAdmin.isCatalogJanitorEnabled()); 734 } 735 736 @Override 737 public CompletableFuture<Integer> runCatalogJanitor() { 738 return wrap(rawAdmin.runCatalogJanitor()); 739 } 740 741 @Override 742 public <S, R> CompletableFuture<R> coprocessorService(Function<RpcChannel, S> stubMaker, 743 ServiceCaller<S, R> callable) { 744 return wrap(rawAdmin.coprocessorService(stubMaker, callable)); 745 } 746 747 @Override 748 public <S, R> CompletableFuture<R> coprocessorService(Function<RpcChannel, S> stubMaker, 749 ServiceCaller<S, R> callable, ServerName serverName) { 750 return wrap(rawAdmin.coprocessorService(stubMaker, callable, serverName)); 751 } 752 753 @Override 754 public CompletableFuture<List<ServerName>> listDeadServers() { 755 return wrap(rawAdmin.listDeadServers()); 756 } 757 758 @Override 759 public CompletableFuture<List<ServerName>> clearDeadServers(List<ServerName> servers) { 760 return wrap(rawAdmin.clearDeadServers(servers)); 761 } 762 763 @Override 764 public CompletableFuture<CacheEvictionStats> clearBlockCache(TableName tableName) { 765 return wrap(rawAdmin.clearBlockCache(tableName)); 766 } 767 768 @Override 769 public CompletableFuture<Void> cloneTableSchema(TableName tableName, TableName newTableName, 770 boolean preserveSplits) { 771 return wrap(rawAdmin.cloneTableSchema(tableName, newTableName, preserveSplits)); 772 } 773 774 @Override 775 public CompletableFuture<Map<ServerName, Boolean>> compactionSwitch(boolean switchState, 776 List<String> serverNamesList) { 777 return wrap(rawAdmin.compactionSwitch(switchState, serverNamesList)); 778 } 779 780 @Override 781 public CompletableFuture<Boolean> switchRpcThrottle(boolean enable) { 782 return wrap(rawAdmin.switchRpcThrottle(enable)); 783 } 784 785 @Override 786 public CompletableFuture<Boolean> isRpcThrottleEnabled() { 787 return wrap(rawAdmin.isRpcThrottleEnabled()); 788 } 789 790 @Override 791 public CompletableFuture<Boolean> exceedThrottleQuotaSwitch(boolean enable) { 792 return wrap(rawAdmin.exceedThrottleQuotaSwitch(enable)); 793 } 794 795 @Override 796 public CompletableFuture<Map<TableName, Long>> getSpaceQuotaTableSizes() { 797 return wrap(rawAdmin.getSpaceQuotaTableSizes()); 798 } 799 800 @Override 801 public CompletableFuture<Map<TableName, SpaceQuotaSnapshot>> getRegionServerSpaceQuotaSnapshots( 802 ServerName serverName) { 803 return wrap(rawAdmin.getRegionServerSpaceQuotaSnapshots(serverName)); 804 } 805 806 @Override 807 public CompletableFuture<SpaceQuotaSnapshot> getCurrentSpaceQuotaSnapshot(String namespace) { 808 return wrap(rawAdmin.getCurrentSpaceQuotaSnapshot(namespace)); 809 } 810 811 @Override 812 public CompletableFuture<SpaceQuotaSnapshot> getCurrentSpaceQuotaSnapshot(TableName tableName) { 813 return wrap(rawAdmin.getCurrentSpaceQuotaSnapshot(tableName)); 814 } 815 816 @Override 817 public CompletableFuture<Void> grant(UserPermission userPermission, 818 boolean mergeExistingPermissions) { 819 return wrap(rawAdmin.grant(userPermission, mergeExistingPermissions)); 820 } 821 822 @Override 823 public CompletableFuture<Void> revoke(UserPermission userPermission) { 824 return wrap(rawAdmin.revoke(userPermission)); 825 } 826 827 @Override 828 public CompletableFuture<List<UserPermission>> 829 getUserPermissions(GetUserPermissionsRequest getUserPermissionsRequest) { 830 return wrap(rawAdmin.getUserPermissions(getUserPermissionsRequest)); 831 } 832 833 @Override 834 public CompletableFuture<List<Boolean>> hasUserPermissions(String userName, 835 List<Permission> permissions) { 836 return wrap(rawAdmin.hasUserPermissions(userName, permissions)); 837 } 838 839 @Override 840 public CompletableFuture<Boolean> snapshotCleanupSwitch(final boolean on, 841 final boolean sync) { 842 return wrap(rawAdmin.snapshotCleanupSwitch(on, sync)); 843 } 844 845 @Override 846 public CompletableFuture<Boolean> isSnapshotCleanupEnabled() { 847 return wrap(rawAdmin.isSnapshotCleanupEnabled()); 848 } 849 850 @Override 851 public CompletableFuture<List<Boolean>> clearSlowLogResponses(Set<ServerName> serverNames) { 852 return wrap(rawAdmin.clearSlowLogResponses(serverNames)); 853 } 854 855 @Override 856 public CompletableFuture<List<LogEntry>> getLogEntries(Set<ServerName> serverNames, 857 String logType, ServerType serverType, int limit, 858 Map<String, Object> filterParams) { 859 return wrap(rawAdmin.getLogEntries(serverNames, logType, serverType, limit, filterParams)); 860 } 861}