How to use

convert

method

in

org.apache.hadoop.hbase.client.replication.ReplicationPeerConfigUtil

public static String convertToString(Map<TableName, ? extends Collection<String>> tableCfs) {
 if (tableCfs == null) {
  return null;
 }
 return convert(convert(tableCfs));
}

/**
 *  Convert tableCFs string into Map.
 * */
public static Map<TableName, List<String>> parseTableCFsFromConfig(String tableCFsConfig) {
 ReplicationProtos.TableCF[] tableCFs = convert(tableCFsConfig);
 return convert2Map(tableCFs);
}

/**
 *  Parse bytes into TableCFs.
 *  It is used for backward compatibility.
 *  Old format bytes have no PB_MAGIC Header
 * */
public static ReplicationProtos.TableCF[] parseTableCFs(byte[] bytes) throws IOException {
 if (bytes == null) {
  return null;
 }
 return ReplicationPeerConfigUtil.convert(Bytes.toString(bytes));
}

/**
 * @param peerConfig
 * @return Serialized protobuf of <code>peerConfig</code> with pb magic prefix prepended suitable
 *         for use as content of a this.peersZNode; i.e. the content of PEER_ID znode under
 *         /hbase/replication/peers/PEER_ID
 */
public static byte[] toByteArray(final ReplicationPeerConfig peerConfig) {
 byte[] bytes = convert(peerConfig).toByteArray();
 return ProtobufUtil.prependPBMagic(bytes);
}

 @Override
 protected void deserializeStateData(ProcedureStateSerializer serializer) throws IOException {
  super.deserializeStateData(serializer);
  UpdatePeerConfigStateData data = serializer.deserialize(UpdatePeerConfigStateData.class);
  peerConfig = ReplicationPeerConfigUtil.convert(data.getPeerConfig());
  if (data.hasOldPeerConfig()) {
   oldPeerConfig = ReplicationPeerConfigUtil.convert(data.getOldPeerConfig());
  } else {
   oldPeerConfig = null;
  }
  enabled = data.getEnabled();
 }
}

@Override
protected void serializeStateData(ProcedureStateSerializer serializer) throws IOException {
 super.serializeStateData(serializer);
 UpdatePeerConfigStateData.Builder builder = UpdatePeerConfigStateData.newBuilder()
  .setPeerConfig(ReplicationPeerConfigUtil.convert(peerConfig));
 if (oldPeerConfig != null) {
  builder.setOldPeerConfig(ReplicationPeerConfigUtil.convert(oldPeerConfig));
 }
 builder.setEnabled(enabled);
 serializer.serialize(builder.build());
}

 @Override
 protected void deserializeStateData(ProcedureStateSerializer serializer) throws IOException {
  super.deserializeStateData(serializer);
  AddPeerStateData data = serializer.deserialize(AddPeerStateData.class);
  peerConfig = ReplicationPeerConfigUtil.convert(data.getPeerConfig());
  enabled = data.getEnabled();
 }
}

 @Override
 protected void deserializeStateData(ProcedureStateSerializer serializer) throws IOException {
  super.deserializeStateData(serializer);
  RemovePeerStateData data = serializer.deserialize(RemovePeerStateData.class);
  if (data.hasPeerConfig()) {
   this.peerConfig = ReplicationPeerConfigUtil.convert(data.getPeerConfig());
  }
 }
}

public static UpdateReplicationPeerConfigRequest buildUpdateReplicationPeerConfigRequest(
  String peerId, ReplicationPeerConfig peerConfig) {
 UpdateReplicationPeerConfigRequest.Builder builder = UpdateReplicationPeerConfigRequest
   .newBuilder();
 builder.setPeerId(peerId);
 builder.setPeerConfig(ReplicationPeerConfigUtil.convert(peerConfig));
 return builder.build();
}

 @Override
 protected ReplicationPeerConfig rpcCall() throws Exception {
  GetReplicationPeerConfigResponse response = master.getReplicationPeerConfig(
   getRpcController(), RequestConverter.buildGetReplicationPeerConfigRequest(peerId));
  return ReplicationPeerConfigUtil.convert(response.getPeerConfig());
 }
});

@Override
protected void serializeStateData(ProcedureStateSerializer serializer) throws IOException {
 super.serializeStateData(serializer);
 RemovePeerStateData.Builder builder = RemovePeerStateData.newBuilder();
 if (peerConfig != null) {
  builder.setPeerConfig(ReplicationPeerConfigUtil.convert(peerConfig));
 }
 serializer.serialize(builder.build());
}

@Override
protected void serializeStateData(ProcedureStateSerializer serializer) throws IOException {
 super.serializeStateData(serializer);
 serializer.serialize(AddPeerStateData.newBuilder()
  .setPeerConfig(ReplicationPeerConfigUtil.convert(peerConfig)).setEnabled(enabled).build());
}

public static ReplicationPeerDescription
  toReplicationPeerDescription(ReplicationProtos.ReplicationPeerDescription desc) {
 boolean enabled =
   ReplicationProtos.ReplicationState.State.ENABLED == desc.getState().getState();
 ReplicationPeerConfig config = convert(desc.getConfig());
 return new ReplicationPeerDescription(desc.getId(), enabled, config,
  toSyncReplicationState(desc.getSyncReplicationState()));
}

@Override
public UpdateReplicationPeerConfigResponse updateReplicationPeerConfig(RpcController controller,
  UpdateReplicationPeerConfigRequest request) throws ServiceException {
 try {
  long procId = master.updateReplicationPeerConfig(request.getPeerId(),
   ReplicationPeerConfigUtil.convert(request.getPeerConfig()));
  return UpdateReplicationPeerConfigResponse.newBuilder().setProcId(procId).build();
 } catch (ReplicationException | IOException e) {
  throw new ServiceException(e);
 }
}

@Override
public CompletableFuture<ReplicationPeerConfig> getReplicationPeerConfig(String peerId) {
 return this.<ReplicationPeerConfig> newMasterCaller().action((controller, stub) -> this
  .<GetReplicationPeerConfigRequest, GetReplicationPeerConfigResponse, ReplicationPeerConfig> call(
   controller, stub, RequestConverter.buildGetReplicationPeerConfigRequest(peerId),
   (s, c, req, done) -> s.getReplicationPeerConfig(c, req, done),
   (resp) -> ReplicationPeerConfigUtil.convert(resp.getPeerConfig())))
  .call();
}

@Override
public GetReplicationPeerConfigResponse getReplicationPeerConfig(RpcController controller,
  GetReplicationPeerConfigRequest request) throws ServiceException {
 GetReplicationPeerConfigResponse.Builder response = GetReplicationPeerConfigResponse
   .newBuilder();
 try {
  String peerId = request.getPeerId();
  ReplicationPeerConfig peerConfig = master.getReplicationPeerConfig(peerId);
  response.setPeerId(peerId);
  response.setPeerConfig(ReplicationPeerConfigUtil.convert(peerConfig));
 } catch (ReplicationException | IOException e) {
  throw new ServiceException(e);
 }
 return response.build();
}

public static ReplicationProtos.AddReplicationPeerRequest buildAddReplicationPeerRequest(
  String peerId, ReplicationPeerConfig peerConfig, boolean enabled) {
 AddReplicationPeerRequest.Builder builder = AddReplicationPeerRequest.newBuilder();
 builder.setPeerId(peerId);
 builder.setPeerConfig(ReplicationPeerConfigUtil.convert(peerConfig));
 ReplicationProtos.ReplicationState.Builder stateBuilder =
   ReplicationProtos.ReplicationState.newBuilder();
 stateBuilder.setState(enabled ? ReplicationProtos.ReplicationState.State.ENABLED
   : ReplicationProtos.ReplicationState.State.DISABLED);
 builder.setPeerState(stateBuilder.build());
 return builder.build();
}

@Override
public AddReplicationPeerResponse addReplicationPeer(RpcController controller,
  AddReplicationPeerRequest request) throws ServiceException {
 try {
  long procId = master.addReplicationPeer(request.getPeerId(),
   ReplicationPeerConfigUtil.convert(request.getPeerConfig()),
   request.getPeerState().getState().equals(ReplicationState.State.ENABLED));
  return AddReplicationPeerResponse.newBuilder().setProcId(procId).build();
 } catch (ReplicationException | IOException e) {
  throw new ServiceException(e);
 }
}

/**
 * @param bytes Content of a peer znode.
 * @return ClusterKey parsed from the passed bytes.
 * @throws DeserializationException
 */
public static ReplicationPeerConfig parsePeerFrom(final byte[] bytes)
  throws DeserializationException {
 if (ProtobufUtil.isPBMagicPrefix(bytes)) {
  int pbLen = ProtobufUtil.lengthOfPBMagic();
  ReplicationProtos.ReplicationPeer.Builder builder =
    ReplicationProtos.ReplicationPeer.newBuilder();
  ReplicationProtos.ReplicationPeer peer;
  try {
   ProtobufUtil.mergeFrom(builder, bytes, pbLen, bytes.length - pbLen);
   peer = builder.build();
  } catch (IOException e) {
   throw new DeserializationException(e);
  }
  return convert(peer);
 } else {
  if (bytes == null || bytes.length <= 0) {
   throw new DeserializationException("Bytes to deserialize should not be empty.");
  }
  return ReplicationPeerConfig.newBuilder().setClusterKey(Bytes.toString(bytes)).build();
 }
}

public static ReplicationProtos.ReplicationPeerDescription
  toProtoReplicationPeerDescription(ReplicationPeerDescription desc) {
 ReplicationProtos.ReplicationPeerDescription.Builder builder =
   ReplicationProtos.ReplicationPeerDescription.newBuilder();
 builder.setId(desc.getPeerId());
 ReplicationProtos.ReplicationState.Builder stateBuilder =
   ReplicationProtos.ReplicationState.newBuilder();
 stateBuilder.setState(desc.isEnabled() ? ReplicationProtos.ReplicationState.State.ENABLED :
   ReplicationProtos.ReplicationState.State.DISABLED);
 builder.setState(stateBuilder.build());
 builder.setConfig(convert(desc.getPeerConfig()));
 builder.setSyncReplicationState(toSyncReplicationState(desc.getSyncReplicationState()));
 return builder.build();
}