Return-Path: X-Original-To: archive-asf-public-internal@cust-asf2.ponee.io Delivered-To: archive-asf-public-internal@cust-asf2.ponee.io Received: from cust-asf.ponee.io (cust-asf.ponee.io [163.172.22.183]) by cust-asf2.ponee.io (Postfix) with ESMTP id 6BB05200D5A for ; Wed, 29 Nov 2017 16:17:46 +0100 (CET) Received: by cust-asf.ponee.io (Postfix) id 6ACAF160C19; Wed, 29 Nov 2017 15:17:46 +0000 (UTC) Delivered-To: archive-asf-public@cust-asf.ponee.io Received: from mail.apache.org (hermes.apache.org [140.211.11.3]) by cust-asf.ponee.io (Postfix) with SMTP id 67475160C1B for ; Wed, 29 Nov 2017 16:17:44 +0100 (CET) Received: (qmail 84996 invoked by uid 500); 29 Nov 2017 15:17:42 -0000 Mailing-List: contact commits-help@hbase.apache.org; run by ezmlm Precedence: bulk List-Help: List-Unsubscribe: List-Post: List-Id: Reply-To: dev@hbase.apache.org Delivered-To: mailing list commits@hbase.apache.org Received: (qmail 84655 invoked by uid 99); 29 Nov 2017 15:17:42 -0000 Received: from git1-us-west.apache.org (HELO git1-us-west.apache.org) (140.211.11.23) by apache.org (qpsmtpd/0.29) with ESMTP; Wed, 29 Nov 2017 15:17:42 +0000 Received: by git1-us-west.apache.org (ASF Mail Server at git1-us-west.apache.org, from userid 33) id 3025AF6062; Wed, 29 Nov 2017 15:17:40 +0000 (UTC) Content-Type: text/plain; charset="us-ascii" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit From: git-site-role@apache.org To: commits@hbase.apache.org Date: Wed, 29 Nov 2017 15:17:49 -0000 Message-Id: <9c8f77693ed844efa6a625b60e3ba950@git.apache.org> In-Reply-To: <5ac02b3974354d02b97ed85ef71ee873@git.apache.org> References: <5ac02b3974354d02b97ed85ef71ee873@git.apache.org> X-Mailer: ASF-Git Admin Mailer Subject: [10/51] [partial] hbase-site git commit: Published site at . archived-at: Wed, 29 Nov 2017 15:17:46 -0000 http://git-wip-us.apache.org/repos/asf/hbase-site/blob/fd365a2b/devapidocs/src-html/org/apache/hadoop/hbase/client/HBaseAdmin.EnableTableFuture.html ---------------------------------------------------------------------- diff --git a/devapidocs/src-html/org/apache/hadoop/hbase/client/HBaseAdmin.EnableTableFuture.html b/devapidocs/src-html/org/apache/hadoop/hbase/client/HBaseAdmin.EnableTableFuture.html index d438f22..7c59e27 100644 --- a/devapidocs/src-html/org/apache/hadoop/hbase/client/HBaseAdmin.EnableTableFuture.html +++ b/devapidocs/src-html/org/apache/hadoop/hbase/client/HBaseAdmin.EnableTableFuture.html @@ -1290,8 +1290,8 @@ 1282 CompactType compactType) throws IOException { 1283 switch (compactType) { 1284 case MOB: -1285 compact(this.connection.getAdminForMaster(), getMobRegionInfo(tableName), major, -1286 columnFamily); +1285 compact(this.connection.getAdminForMaster(), RegionInfo.createMobRegionInfo(tableName), +1286 major, columnFamily); 1287 break; 1288 case NORMAL: 1289 checkTableExists(tableName); @@ -3248,7 +3248,7 @@ 3240 new Callable<AdminProtos.GetRegionInfoResponse.CompactionState>() { 3241 @Override 3242 public AdminProtos.GetRegionInfoResponse.CompactionState call() throws Exception { -3243 RegionInfo info = getMobRegionInfo(tableName); +3243 RegionInfo info = RegionInfo.createMobRegionInfo(tableName); 3244 GetRegionInfoRequest request = 3245 RequestConverter.buildGetRegionInfoRequest(info.getRegionName(), true); 3246 GetRegionInfoResponse response = masterAdmin.getRegionInfo(rpcController, request); @@ -3312,7 +3312,7 @@ 3304 } 3305 break; 3306 default: -3307 throw new IllegalArgumentException("Unknowne compactType: " + compactType); +3307 throw new IllegalArgumentException("Unknown compactType: " + compactType); 3308 } 3309 if (state != null) { 3310 return ProtobufUtil.createCompactionState(state); @@ -3847,325 +3847,320 @@ 3839 }); 3840 } 3841 -3842 private RegionInfo getMobRegionInfo(TableName tableName) { -3843 return RegionInfoBuilder.newBuilder(tableName).setStartKey(Bytes.toBytes(".mob")).setRegionId(0) -3844 .build(); -3845 } -3846 -3847 private RpcControllerFactory getRpcControllerFactory() { -3848 return this.rpcControllerFactory; -3849 } -3850 -3851 @Override -3852 public void addReplicationPeer(String peerId, ReplicationPeerConfig peerConfig, boolean enabled) -3853 throws IOException { -3854 executeCallable(new MasterCallable<Void>(getConnection(), getRpcControllerFactory()) { -3855 @Override -3856 protected Void rpcCall() throws Exception { -3857 master.addReplicationPeer(getRpcController(), -3858 RequestConverter.buildAddReplicationPeerRequest(peerId, peerConfig, enabled)); -3859 return null; -3860 } -3861 }); -3862 } -3863 -3864 @Override -3865 public void removeReplicationPeer(String peerId) throws IOException { -3866 executeCallable(new MasterCallable<Void>(getConnection(), getRpcControllerFactory()) { -3867 @Override -3868 protected Void rpcCall() throws Exception { -3869 master.removeReplicationPeer(getRpcController(), -3870 RequestConverter.buildRemoveReplicationPeerRequest(peerId)); -3871 return null; -3872 } -3873 }); -3874 } -3875 -3876 @Override -3877 public void enableReplicationPeer(final String peerId) throws IOException { -3878 executeCallable(new MasterCallable<Void>(getConnection(), getRpcControllerFactory()) { -3879 @Override -3880 protected Void rpcCall() throws Exception { -3881 master.enableReplicationPeer(getRpcController(), -3882 RequestConverter.buildEnableReplicationPeerRequest(peerId)); -3883 return null; -3884 } -3885 }); -3886 } -3887 -3888 @Override -3889 public void disableReplicationPeer(final String peerId) throws IOException { -3890 executeCallable(new MasterCallable<Void>(getConnection(), getRpcControllerFactory()) { -3891 @Override -3892 protected Void rpcCall() throws Exception { -3893 master.disableReplicationPeer(getRpcController(), -3894 RequestConverter.buildDisableReplicationPeerRequest(peerId)); -3895 return null; -3896 } -3897 }); -3898 } -3899 -3900 @Override -3901 public ReplicationPeerConfig getReplicationPeerConfig(final String peerId) throws IOException { -3902 return executeCallable(new MasterCallable<ReplicationPeerConfig>(getConnection(), -3903 getRpcControllerFactory()) { -3904 @Override -3905 protected ReplicationPeerConfig rpcCall() throws Exception { -3906 GetReplicationPeerConfigResponse response = master.getReplicationPeerConfig( -3907 getRpcController(), RequestConverter.buildGetReplicationPeerConfigRequest(peerId)); -3908 return ReplicationPeerConfigUtil.convert(response.getPeerConfig()); -3909 } -3910 }); -3911 } -3912 -3913 @Override -3914 public void updateReplicationPeerConfig(final String peerId, -3915 final ReplicationPeerConfig peerConfig) throws IOException { -3916 executeCallable(new MasterCallable<Void>(getConnection(), getRpcControllerFactory()) { -3917 @Override -3918 protected Void rpcCall() throws Exception { -3919 master.updateReplicationPeerConfig(getRpcController(), -3920 RequestConverter.buildUpdateReplicationPeerConfigRequest(peerId, peerConfig)); -3921 return null; -3922 } -3923 }); -3924 } -3925 -3926 @Override -3927 public void appendReplicationPeerTableCFs(String id, -3928 Map<TableName, ? extends Collection<String>> tableCfs) throws ReplicationException, -3929 IOException { -3930 if (tableCfs == null) { -3931 throw new ReplicationException("tableCfs is null"); -3932 } -3933 ReplicationPeerConfig peerConfig = getReplicationPeerConfig(id); -3934 ReplicationPeerConfigUtil.appendTableCFsToReplicationPeerConfig(tableCfs, peerConfig); -3935 updateReplicationPeerConfig(id, peerConfig); -3936 } -3937 -3938 @Override -3939 public void removeReplicationPeerTableCFs(String id, -3940 Map<TableName, ? extends Collection<String>> tableCfs) throws ReplicationException, -3941 IOException { -3942 if (tableCfs == null) { -3943 throw new ReplicationException("tableCfs is null"); -3944 } -3945 ReplicationPeerConfig peerConfig = getReplicationPeerConfig(id); -3946 ReplicationPeerConfigUtil.removeTableCFsFromReplicationPeerConfig(tableCfs, peerConfig, id); -3947 updateReplicationPeerConfig(id, peerConfig); +3842 private RpcControllerFactory getRpcControllerFactory() { +3843 return this.rpcControllerFactory; +3844 } +3845 +3846 @Override +3847 public void addReplicationPeer(String peerId, ReplicationPeerConfig peerConfig, boolean enabled) +3848 throws IOException { +3849 executeCallable(new MasterCallable<Void>(getConnection(), getRpcControllerFactory()) { +3850 @Override +3851 protected Void rpcCall() throws Exception { +3852 master.addReplicationPeer(getRpcController(), +3853 RequestConverter.buildAddReplicationPeerRequest(peerId, peerConfig, enabled)); +3854 return null; +3855 } +3856 }); +3857 } +3858 +3859 @Override +3860 public void removeReplicationPeer(String peerId) throws IOException { +3861 executeCallable(new MasterCallable<Void>(getConnection(), getRpcControllerFactory()) { +3862 @Override +3863 protected Void rpcCall() throws Exception { +3864 master.removeReplicationPeer(getRpcController(), +3865 RequestConverter.buildRemoveReplicationPeerRequest(peerId)); +3866 return null; +3867 } +3868 }); +3869 } +3870 +3871 @Override +3872 public void enableReplicationPeer(final String peerId) throws IOException { +3873 executeCallable(new MasterCallable<Void>(getConnection(), getRpcControllerFactory()) { +3874 @Override +3875 protected Void rpcCall() throws Exception { +3876 master.enableReplicationPeer(getRpcController(), +3877 RequestConverter.buildEnableReplicationPeerRequest(peerId)); +3878 return null; +3879 } +3880 }); +3881 } +3882 +3883 @Override +3884 public void disableReplicationPeer(final String peerId) throws IOException { +3885 executeCallable(new MasterCallable<Void>(getConnection(), getRpcControllerFactory()) { +3886 @Override +3887 protected Void rpcCall() throws Exception { +3888 master.disableReplicationPeer(getRpcController(), +3889 RequestConverter.buildDisableReplicationPeerRequest(peerId)); +3890 return null; +3891 } +3892 }); +3893 } +3894 +3895 @Override +3896 public ReplicationPeerConfig getReplicationPeerConfig(final String peerId) throws IOException { +3897 return executeCallable(new MasterCallable<ReplicationPeerConfig>(getConnection(), +3898 getRpcControllerFactory()) { +3899 @Override +3900 protected ReplicationPeerConfig rpcCall() throws Exception { +3901 GetReplicationPeerConfigResponse response = master.getReplicationPeerConfig( +3902 getRpcController(), RequestConverter.buildGetReplicationPeerConfigRequest(peerId)); +3903 return ReplicationPeerConfigUtil.convert(response.getPeerConfig()); +3904 } +3905 }); +3906 } +3907 +3908 @Override +3909 public void updateReplicationPeerConfig(final String peerId, +3910 final ReplicationPeerConfig peerConfig) throws IOException { +3911 executeCallable(new MasterCallable<Void>(getConnection(), getRpcControllerFactory()) { +3912 @Override +3913 protected Void rpcCall() throws Exception { +3914 master.updateReplicationPeerConfig(getRpcController(), +3915 RequestConverter.buildUpdateReplicationPeerConfigRequest(peerId, peerConfig)); +3916 return null; +3917 } +3918 }); +3919 } +3920 +3921 @Override +3922 public void appendReplicationPeerTableCFs(String id, +3923 Map<TableName, ? extends Collection<String>> tableCfs) throws ReplicationException, +3924 IOException { +3925 if (tableCfs == null) { +3926 throw new ReplicationException("tableCfs is null"); +3927 } +3928 ReplicationPeerConfig peerConfig = getReplicationPeerConfig(id); +3929 ReplicationPeerConfigUtil.appendTableCFsToReplicationPeerConfig(tableCfs, peerConfig); +3930 updateReplicationPeerConfig(id, peerConfig); +3931 } +3932 +3933 @Override +3934 public void removeReplicationPeerTableCFs(String id, +3935 Map<TableName, ? extends Collection<String>> tableCfs) throws ReplicationException, +3936 IOException { +3937 if (tableCfs == null) { +3938 throw new ReplicationException("tableCfs is null"); +3939 } +3940 ReplicationPeerConfig peerConfig = getReplicationPeerConfig(id); +3941 ReplicationPeerConfigUtil.removeTableCFsFromReplicationPeerConfig(tableCfs, peerConfig, id); +3942 updateReplicationPeerConfig(id, peerConfig); +3943 } +3944 +3945 @Override +3946 public List<ReplicationPeerDescription> listReplicationPeers() throws IOException { +3947 return listReplicationPeers((Pattern)null); 3948 } 3949 3950 @Override -3951 public List<ReplicationPeerDescription> listReplicationPeers() throws IOException { -3952 return listReplicationPeers((Pattern)null); -3953 } -3954 -3955 @Override -3956 public List<ReplicationPeerDescription> listReplicationPeers(Pattern pattern) -3957 throws IOException { -3958 return executeCallable(new MasterCallable<List<ReplicationPeerDescription>>(getConnection(), -3959 getRpcControllerFactory()) { -3960 @Override -3961 protected List<ReplicationPeerDescription> rpcCall() throws Exception { -3962 List<ReplicationProtos.ReplicationPeerDescription> peersList = master.listReplicationPeers( -3963 getRpcController(), RequestConverter.buildListReplicationPeersRequest(pattern)) -3964 .getPeerDescList(); -3965 List<ReplicationPeerDescription> result = new ArrayList<>(peersList.size()); -3966 for (ReplicationProtos.ReplicationPeerDescription peer : peersList) { -3967 result.add(ReplicationPeerConfigUtil.toReplicationPeerDescription(peer)); -3968 } -3969 return result; -3970 } -3971 }); -3972 } -3973 -3974 @Override -3975 public void decommissionRegionServers(List<ServerName> servers, boolean offload) -3976 throws IOException { -3977 executeCallable(new MasterCallable<Void>(getConnection(), getRpcControllerFactory()) { -3978 @Override -3979 public Void rpcCall() throws ServiceException { -3980 master.decommissionRegionServers(getRpcController(), -3981 RequestConverter.buildDecommissionRegionServersRequest(servers, offload)); -3982 return null; -3983 } -3984 }); -3985 } -3986 -3987 @Override -3988 public List<ServerName> listDecommissionedRegionServers() throws IOException { -3989 return executeCallable(new MasterCallable<List<ServerName>>(getConnection(), -3990 getRpcControllerFactory()) { -3991 @Override -3992 public List<ServerName> rpcCall() throws ServiceException { -3993 ListDecommissionedRegionServersRequest req = ListDecommissionedRegionServersRequest.newBuilder().build(); -3994 List<ServerName> servers = new ArrayList<>(); -3995 for (HBaseProtos.ServerName server : master -3996 .listDecommissionedRegionServers(getRpcController(), req).getServerNameList()) { -3997 servers.add(ProtobufUtil.toServerName(server)); -3998 } -3999 return servers; -4000 } -4001 }); -4002 } -4003 -4004 @Override -4005 public void recommissionRegionServer(ServerName server, List<byte[]> encodedRegionNames) -4006 throws IOException { -4007 executeCallable(new MasterCallable<Void>(getConnection(), getRpcControllerFactory()) { -4008 @Override -4009 public Void rpcCall() throws ServiceException { -4010 master.recommissionRegionServer(getRpcController(), -4011 RequestConverter.buildRecommissionRegionServerRequest(server, encodedRegionNames)); -4012 return null; -4013 } -4014 }); -4015 } -4016 -4017 @Override -4018 public List<TableCFs> listReplicatedTableCFs() throws IOException { -4019 List<TableCFs> replicatedTableCFs = new ArrayList<>(); -4020 List<TableDescriptor> tables = listTableDescriptors(); -4021 tables.forEach(table -> { -4022 Map<String, Integer> cfs = new HashMap<>(); -4023 Stream.of(table.getColumnFamilies()) -4024 .filter(column -> column.getScope() != HConstants.REPLICATION_SCOPE_LOCAL) -4025 .forEach(column -> { -4026 cfs.put(column.getNameAsString(), column.getScope()); -4027 }); -4028 if (!cfs.isEmpty()) { -4029 replicatedTableCFs.add(new TableCFs(table.getTableName(), cfs)); -4030 } -4031 }); -4032 return replicatedTableCFs; -4033 } -4034 -4035 @Override -4036 public void enableTableReplication(final TableName tableName) throws IOException { -4037 if (tableName == null) { -4038 throw new IllegalArgumentException("Table name cannot be null"); -4039 } -4040 if (!tableExists(tableName)) { -4041 throw new TableNotFoundException("Table '" + tableName.getNameAsString() -4042 + "' does not exists."); -4043 } -4044 byte[][] splits = getTableSplits(tableName); -4045 checkAndSyncTableDescToPeers(tableName, splits); -4046 setTableRep(tableName, true); -4047 } -4048 -4049 @Override -4050 public void disableTableReplication(final TableName tableName) throws IOException { -4051 if (tableName == null) { -4052 throw new IllegalArgumentException("Table name is null"); -4053 } -4054 if (!tableExists(tableName)) { -4055 throw new TableNotFoundException("Table '" + tableName.getNameAsString() -4056 + "' does not exists."); -4057 } -4058 setTableRep(tableName, false); -4059 } -4060 -4061 /** -4062 * Connect to peer and check the table descriptor on peer: -4063 * <ol> -4064 * <li>Create the same table on peer when not exist.</li> -4065 * <li>Throw an exception if the table already has replication enabled on any of the column -4066 * families.</li> -4067 * <li>Throw an exception if the table exists on peer cluster but descriptors are not same.</li> -4068 * </ol> -4069 * @param tableName name of the table to sync to the peer -4070 * @param splits table split keys -4071 * @throws IOException -4072 */ -4073 private void checkAndSyncTableDescToPeers(final TableName tableName, final byte[][] splits) -4074 throws IOException { -4075 List<ReplicationPeerDescription> peers = listReplicationPeers(); -4076 if (peers == null || peers.size() <= 0) { -4077 throw new IllegalArgumentException("Found no peer cluster for replication."); -4078 } -4079 -4080 for (ReplicationPeerDescription peerDesc : peers) { -4081 if (peerDesc.getPeerConfig().needToReplicate(tableName)) { -4082 Configuration peerConf = -4083 ReplicationPeerConfigUtil.getPeerClusterConfiguration(this.conf, peerDesc); -4084 try (Connection conn = ConnectionFactory.createConnection(peerConf); -4085 Admin repHBaseAdmin = conn.getAdmin()) { -4086 TableDescriptor tableDesc = getDescriptor(tableName); -4087 TableDescriptor peerTableDesc = null; -4088 if (!repHBaseAdmin.tableExists(tableName)) { -4089 repHBaseAdmin.createTable(tableDesc, splits); -4090 } else { -4091 peerTableDesc = repHBaseAdmin.getDescriptor(tableName); -4092 if (peerTableDesc == null) { -4093 throw new IllegalArgumentException("Failed to get table descriptor for table " -4094 + tableName.getNameAsString() + " from peer cluster " + peerDesc.getPeerId()); -4095 } -4096 if (TableDescriptor.COMPARATOR_IGNORE_REPLICATION.compare(peerTableDesc, -4097 tableDesc) != 0) { -4098 throw new IllegalArgumentException("Table " + tableName.getNameAsString() -4099 + " exists in peer cluster " + peerDesc.getPeerId() -4100 + ", but the table descriptors are not same when compared with source cluster." -4101 + " Thus can not enable the table's replication switch."); -4102 } -4103 } -4104 } -4105 } -4106 } -4107 } -4108 -4109 /** -4110 * Set the table's replication switch if the table's replication switch is already not set. -4111 * @param tableName name of the table -4112 * @param enableRep is replication switch enable or disable -4113 * @throws IOException if a remote or network exception occurs -4114 */ -4115 private void setTableRep(final TableName tableName, boolean enableRep) throws IOException { -4116 TableDescriptor tableDesc = getDescriptor(tableName); -4117 if (!tableDesc.matchReplicationScope(enableRep)) { -4118 int scope = -4119 enableRep ? HConstants.REPLICATION_SCOPE_GLOBAL : HConstants.REPLICATION_SCOPE_LOCAL; -4120 modifyTable(TableDescriptorBuilder.newBuilder(tableDesc).setReplicationScope(scope).build()); -4121 } -4122 } -4123 -4124 @Override -4125 public void clearCompactionQueues(final ServerName sn, final Set<String> queues) -4126 throws IOException, InterruptedException { -4127 if (queues == null || queues.size() == 0) { -4128 throw new IllegalArgumentException("queues cannot be null or empty"); -4129 } -4130 final AdminService.BlockingInterface admin = this.connection.getAdmin(sn); -4131 Callable<Void> callable = new Callable<Void>() { -4132 @Override -4133 public Void call() throws Exception { -4134 // TODO: There is no timeout on this controller. Set one! -4135 HBaseRpcController controller = rpcControllerFactory.newController(); -4136 ClearCompactionQueuesRequest request = -4137 RequestConverter.buildClearCompactionQueuesRequest(queues); -4138 admin.clearCompactionQueues(controller, request); -4139 return null; -4140 } -4141 }; -4142 ProtobufUtil.call(callable); -4143 } -4144 -4145 @Override -4146 public List<ServerName> clearDeadServers(final List<ServerName> servers) throws IOException { -4147 if (servers == null || servers.size() == 0) { -4148 throw new IllegalArgumentException("servers cannot be null or empty"); -4149 } -4150 return executeCallable(new MasterCallable<List<ServerName>>(getConnection(), -4151 getRpcControllerFactory()) { -4152 @Override -4153 protected List<ServerName> rpcCall() throws Exception { -4154 ClearDeadServersRequest req = RequestConverter.buildClearDeadServersRequest(servers); -4155 return ProtobufUtil.toServerNameList( -4156 master.clearDeadServers(getRpcController(), req).getServerNameList()); -4157 } -4158 }); -4159 } -4160} +3951 public List<ReplicationPeerDescription> listReplicationPeers(Pattern pattern) +3952 throws IOException { +3953 return executeCallable(new MasterCallable<List<ReplicationPeerDescription>>(getConnection(), +3954 getRpcControllerFactory()) { +3955 @Override +3956 protected List<ReplicationPeerDescription> rpcCall() throws Exception { +3957 List<ReplicationProtos.ReplicationPeerDescription> peersList = master.listReplicationPeers( +3958 getRpcController(), RequestConverter.buildListReplicationPeersRequest(pattern)) +3959 .getPeerDescList(); +3960 List<ReplicationPeerDescription> result = new ArrayList<>(peersList.size()); +3961 for (ReplicationProtos.ReplicationPeerDescription peer : peersList) { +3962 result.add(ReplicationPeerConfigUtil.toReplicationPeerDescription(peer)); +3963 } +3964 return result; +3965 } +3966 }); +3967 } +3968 +3969 @Override +3970 public void decommissionRegionServers(List<ServerName> servers, boolean offload) +3971 throws IOException { +3972 executeCallable(new MasterCallable<Void>(getConnection(), getRpcControllerFactory()) { +3973 @Override +3974 public Void rpcCall() throws ServiceException { +3975 master.decommissionRegionServers(getRpcController(), +3976 RequestConverter.buildDecommissionRegionServersRequest(servers, offload)); +3977 return null; +3978 } +3979 }); +3980 } +3981 +3982 @Override +3983 public List<ServerName> listDecommissionedRegionServers() throws IOException { +3984 return executeCallable(new MasterCallable<List<ServerName>>(getConnection(), +3985 getRpcControllerFactory()) { +3986 @Override +3987 public List<ServerName> rpcCall() throws ServiceException { +3988 ListDecommissionedRegionServersRequest req = ListDecommissionedRegionServersRequest.newBuilder().build(); +3989 List<ServerName> servers = new ArrayList<>(); +3990 for (HBaseProtos.ServerName server : master +3991 .listDecommissionedRegionServers(getRpcController(), req).getServerNameList()) { +3992 servers.add(ProtobufUtil.toServerName(server)); +3993 } +3994 return servers; +3995 } +3996 }); +3997 } +3998 +3999 @Override +4000 public void recommissionRegionServer(ServerName server, List<byte[]> encodedRegionNames) +4001 throws IOException { +4002 executeCallable(new MasterCallable<Void>(getConnection(), getRpcControllerFactory()) { +4003 @Override +4004 public Void rpcCall() throws ServiceException { +4005 master.recommissionRegionServer(getRpcController(), +4006 RequestConverter.buildRecommissionRegionServerRequest(server, encodedRegionNames)); +4007 return null; +4008 } +4009 }); +4010 } +4011 +4012 @Override +4013 public List<TableCFs> listReplicatedTableCFs() throws IOException { +4014 List<TableCFs> replicatedTableCFs = new ArrayList<>(); +4015 List<TableDescriptor> tables = listTableDescriptors(); +4016 tables.forEach(table -> { +4017 Map<String, Integer> cfs = new HashMap<>(); +4018 Stream.of(table.getColumnFamilies()) +4019 .filter(column -> column.getScope() != HConstants.REPLICATION_SCOPE_LOCAL) +4020 .forEach(column -> { +4021 cfs.put(column.getNameAsString(), column.getScope()); +4022 }); +4023 if (!cfs.isEmpty()) { +4024 replicatedTableCFs.add(new TableCFs(table.getTableName(), cfs)); +4025 } +4026 }); +4027 return replicatedTableCFs; +4028 } +4029 +4030 @Override +4031 public void enableTableReplication(final TableName tableName) throws IOException { +4032 if (tableName == null) { +4033 throw new IllegalArgumentException("Table name cannot be null"); +4034 } +4035 if (!tableExists(tableName)) { +4036 throw new TableNotFoundException("Table '" + tableName.getNameAsString() +4037 + "' does not exists."); +4038 } +4039 byte[][] splits = getTableSplits(tableName); +4040 checkAndSyncTableDescToPeers(tableName, splits); +4041 setTableRep(tableName, true); +4042 } +4043 +4044 @Override +4045 public void disableTableReplication(final TableName tableName) throws IOException { +4046 if (tableName == null) { +4047 throw new IllegalArgumentException("Table name is null"); +4048 } +4049 if (!tableExists(tableName)) { +4050 throw new TableNotFoundException("Table '" + tableName.getNameAsString() +4051 + "' does not exists."); +4052 } +4053 setTableRep(tableName, false); +4054 } +4055 +4056 /** +4057 * Connect to peer and check the table descriptor on peer: +4058 * <ol> +4059 * <li>Create the same table on peer when not exist.</li> +4060 * <li>Throw an exception if the table already has replication enabled on any of the column +4061 * families.</li> +4062 * <li>Throw an exception if the table exists on peer cluster but descriptors are not same.</li> +4063 * </ol> +4064 * @param tableName name of the table to sync to the peer +4065 * @param splits table split keys +4066 * @throws IOException +4067 */ +4068 private void checkAndSyncTableDescToPeers(final TableName tableName, final byte[][] splits) +4069 throws IOException { +4070 List<ReplicationPeerDescription> peers = listReplicationPeers(); +4071 if (peers == null || peers.size() <= 0) { +4072 throw new IllegalArgumentException("Found no peer cluster for replication."); +4073 } +4074 +4075 for (ReplicationPeerDescription peerDesc : peers) { +4076 if (peerDesc.getPeerConfig().needToReplicate(tableName)) { +4077 Configuration peerConf = +4078 ReplicationPeerConfigUtil.getPeerClusterConfiguration(this.conf, peerDesc); +4079 try (Connection conn = ConnectionFactory.createConnection(peerConf); +4080 Admin repHBaseAdmin = conn.getAdmin()) { +4081 TableDescriptor tableDesc = getDescriptor(tableName); +4082 TableDescriptor peerTableDesc = null; +4083 if (!repHBaseAdmin.tableExists(tableName)) { +4084 repHBaseAdmin.createTable(tableDesc, splits); +4085 } else { +4086 peerTableDesc = repHBaseAdmin.getDescriptor(tableName); +4087 if (peerTableDesc == null) { +4088 throw new IllegalArgumentException("Failed to get table descriptor for table " +4089 + tableName.getNameAsString() + " from peer cluster " + peerDesc.getPeerId()); +4090 } +4091 if (TableDescriptor.COMPARATOR_IGNORE_REPLICATION.compare(peerTableDesc, +4092 tableDesc) != 0) { +4093 throw new IllegalArgumentException("Table " + tableName.getNameAsString() +4094 + " exists in peer cluster " + peerDesc.getPeerId() +4095 + ", but the table descriptors are not same when compared with source cluster." +4096 + " Thus can not enable the table's replication switch."); +4097 } +4098 } +4099 } +4100 } +4101 } +4102 } +4103 +4104 /** +4105 * Set the table's replication switch if the table's replication switch is already not set. +4106 * @param tableName name of the table +4107 * @param enableRep is replication switch enable or disable +4108 * @throws IOException if a remote or network exception occurs +4109 */ +4110 private void setTableRep(final TableName tableName, boolean enableRep) throws IOException { +4111 TableDescriptor tableDesc = getDescriptor(tableName); +4112 if (!tableDesc.matchReplicationScope(enableRep)) { +4113 int scope = +4114 enableRep ? HConstants.REPLICATION_SCOPE_GLOBAL : HConstants.REPLICATION_SCOPE_LOCAL; +4115 modifyTable(TableDescriptorBuilder.newBuilder(tableDesc).setReplicationScope(scope).build()); +4116 } +4117 } +4118 +4119 @Override +4120 public void clearCompactionQueues(final ServerName sn, final Set<String> queues) +4121 throws IOException, InterruptedException { +4122 if (queues == null || queues.size() == 0) { +4123 throw new IllegalArgumentException("queues cannot be null or empty"); +4124 } +4125 final AdminService.BlockingInterface admin = this.connection.getAdmin(sn); +4126 Callable<Void> callable = new Callable<Void>() { +4127 @Override +4128 public Void call() throws Exception { +4129 // TODO: There is no timeout on this controller. Set one! +4130 HBaseRpcController controller = rpcControllerFactory.newController(); +4131 ClearCompactionQueuesRequest request = +4132 RequestConverter.buildClearCompactionQueuesRequest(queues); +4133 admin.clearCompactionQueues(controller, request); +4134 return null; +4135 } +4136 }; +4137 ProtobufUtil.call(callable); +4138 } +4139 +4140 @Override +4141 public List<ServerName> clearDeadServers(final List<ServerName> servers) throws IOException { +4142 if (servers == null || servers.size() == 0) { +4143 throw new IllegalArgumentException("servers cannot be null or empty"); +4144 } +4145 return executeCallable(new MasterCallable<List<ServerName>>(getConnection(), +4146 getRpcControllerFactory()) { +4147 @Override +4148 protected List<ServerName> rpcCall() throws Exception { +4149 ClearDeadServersRequest req = RequestConverter.buildClearDeadServersRequest(servers); +4150 return ProtobufUtil.toServerNameList( +4151 master.clearDeadServers(getRpcController(), req).getServerNameList()); +4152 } +4153 }); +4154 } +4155}