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