org.apache.ratis.rpc.SupportedRpcType Java Examples

/**
 * Sends ratis command to destroy pipeline on the given datanode.
 *
 * @param dn         - Datanode on which pipeline needs to be destroyed
 * @param pipelineID - ID of pipeline to be destroyed
 * @param ozoneConf  - Ozone configuration
 * @param grpcTlsConfig - grpc tls configuration
 * @throws IOException
 */
static void destroyPipeline(DatanodeDetails dn, PipelineID pipelineID,
    ConfigurationSource ozoneConf, GrpcTlsConfig grpcTlsConfig)
    throws IOException {
  final String rpcType = ozoneConf
      .get(ScmConfigKeys.DFS_CONTAINER_RATIS_RPC_TYPE_KEY,
          ScmConfigKeys.DFS_CONTAINER_RATIS_RPC_TYPE_DEFAULT);
  final RetryPolicy retryPolicy = RatisHelper.createRetryPolicy(ozoneConf);
  final RaftPeer p = RatisHelper.toRaftPeer(dn);
  try(RaftClient client = RatisHelper
      .newRaftClient(SupportedRpcType.valueOfIgnoreCase(rpcType), p,
          retryPolicy, grpcTlsConfig, ozoneConf)) {
    client.groupRemove(RaftGroupId.valueOf(pipelineID.getId()),
        true, p.getId());
  }
}
 

public static XceiverClientRatis newXceiverClientRatis(
    org.apache.hadoop.hdds.scm.pipeline.Pipeline pipeline,
    ConfigurationSource ozoneConf, X509Certificate caCert) {
  final String rpcType = ozoneConf
      .get(ScmConfigKeys.DFS_CONTAINER_RATIS_RPC_TYPE_KEY,
          ScmConfigKeys.DFS_CONTAINER_RATIS_RPC_TYPE_DEFAULT);
  final RetryPolicy retryPolicy = RatisHelper.createRetryPolicy(ozoneConf);
  final GrpcTlsConfig tlsConfig = RatisHelper.createTlsClientConfig(new
      SecurityConfig(ozoneConf), caCert);
  return new XceiverClientRatis(pipeline,
      SupportedRpcType.valueOfIgnoreCase(rpcType),
      retryPolicy, tlsConfig, ozoneConf);
}
 

private RpcType setRpcType(RaftProperties properties) {
  final String rpcType = conf.get(
      OzoneConfigKeys.DFS_CONTAINER_RATIS_RPC_TYPE_KEY,
      OzoneConfigKeys.DFS_CONTAINER_RATIS_RPC_TYPE_DEFAULT);
  final RpcType rpc = SupportedRpcType.valueOfIgnoreCase(rpcType);
  RaftConfigKeys.Rpc.setType(properties, rpc);
  return rpc;
}
 

@SuppressWarnings("checkstyle:ParameterNumber")
private static RaftClient newRaftClient(RpcType rpcType, RaftPeerId leader,
    RaftGroup group, RetryPolicy retryPolicy,
    GrpcTlsConfig tlsConfig, ConfigurationSource ozoneConfiguration) {
  if (LOG.isTraceEnabled()) {
    LOG.trace("newRaftClient: {}, leader={}, group={}",
        rpcType, leader, group);
  }
  final RaftProperties properties = new RaftProperties();

  RaftConfigKeys.Rpc.setType(properties, rpcType);

  // Set the ratis client headers which are matching with regex.
  createRaftClientProperties(ozoneConfiguration, properties);

  RaftClient.Builder builder =  RaftClient.newBuilder()
      .setRaftGroup(group)
      .setLeaderId(leader)
      .setProperties(properties)
      .setRetryPolicy(retryPolicy);

  // TODO: GRPC TLS only for now, netty/hadoop RPC TLS support later.
  if (tlsConfig != null && rpcType == SupportedRpcType.GRPC) {
    builder.setParameters(GrpcFactory.newRaftParameters(tlsConfig));
  }
  return builder.build();
}
 

@Override
public void run() throws Exception {
  int raftSegmentPreallocatedSize = 1024 * 1024 * 1024;
  RaftProperties raftProperties = new RaftProperties();
  RaftConfigKeys.Rpc.setType(raftProperties, SupportedRpcType.GRPC);
  GrpcConfigKeys.setMessageSizeMax(raftProperties,
      SizeInBytes.valueOf(raftSegmentPreallocatedSize));
  RaftServerConfigKeys.Log.Appender.setBufferByteLimit(raftProperties,
      SizeInBytes.valueOf(raftSegmentPreallocatedSize));
  RaftServerConfigKeys.Log.setWriteBufferSize(raftProperties,
      SizeInBytes.valueOf(raftSegmentPreallocatedSize));
  RaftServerConfigKeys.Log.setPreallocatedSize(raftProperties,
      SizeInBytes.valueOf(raftSegmentPreallocatedSize));
  RaftServerConfigKeys.Log.setSegmentSizeMax(raftProperties,
      SizeInBytes.valueOf(1 * 1024 * 1024 * 1024));

  RaftServerConfigKeys.Log.setMaxCachedSegmentNum(raftProperties, 2);

  RaftClientConfigKeys.Rpc.setRequestTimeout(raftProperties,
      TimeDuration.valueOf(50000, TimeUnit.MILLISECONDS));
  RaftClientConfigKeys.Async.setSchedulerThreads(raftProperties, 10);
  RaftClientConfigKeys.Async.setMaxOutstandingRequests(raftProperties, 1000);


  final RaftGroup raftGroup = RaftGroup.valueOf(RaftGroupId.valueOf(ByteString.copyFromUtf8(raftGroupId)),
      parsePeers(peers));

  RaftClient.Builder builder =
      RaftClient.newBuilder().setProperties(raftProperties);
  builder.setRaftGroup(raftGroup);
  builder.setClientRpc(new GrpcFactory(new Parameters()).newRaftClientRpc(ClientId.randomId(), raftProperties));
  RaftClient client = builder.build();

  operation(client);
}
 

@Override
public void run() throws Exception {
  int raftSegmentPreallocatedSize = 1024 * 1024 * 1024;
  RaftProperties raftProperties = new RaftProperties();
  RaftConfigKeys.Rpc.setType(raftProperties, SupportedRpcType.GRPC);
  GrpcConfigKeys.setMessageSizeMax(raftProperties,
      SizeInBytes.valueOf(raftSegmentPreallocatedSize));
  RaftServerConfigKeys.Log.Appender.setBufferByteLimit(raftProperties,
      SizeInBytes.valueOf(raftSegmentPreallocatedSize));
  RaftServerConfigKeys.Log.setWriteBufferSize(raftProperties,
      SizeInBytes.valueOf(raftSegmentPreallocatedSize));
  RaftServerConfigKeys.Log.setPreallocatedSize(raftProperties,
      SizeInBytes.valueOf(raftSegmentPreallocatedSize));
  RaftServerConfigKeys.Log.setSegmentSizeMax(raftProperties,
      SizeInBytes.valueOf(1 * 1024 * 1024 * 1024));

  RaftServerConfigKeys.Log.setSegmentCacheNumMax(raftProperties, 2);

  RaftClientConfigKeys.Rpc.setRequestTimeout(raftProperties,
      TimeDuration.valueOf(50000, TimeUnit.MILLISECONDS));
  RaftClientConfigKeys.Async.setOutstandingRequestsMax(raftProperties, 1000);


  final RaftGroup raftGroup = RaftGroup.valueOf(RaftGroupId.valueOf(ByteString.copyFromUtf8(getRaftGroupId())),
          getPeers());

  RaftClient.Builder builder =
      RaftClient.newBuilder().setProperties(raftProperties);
  builder.setRaftGroup(raftGroup);
  builder.setClientRpc(new GrpcFactory(new Parameters()).newRaftClientRpc(ClientId.randomId(), raftProperties));
  RaftClient client = builder.build();

  operation(client);
}
 

@Override
public SupportedRpcType getRpcType() {
  return SupportedRpcType.NETTY;
}
 

@Override
public MiniRaftClusterWithNetty newCluster(String[] ids, RaftProperties prop) {
  RaftConfigKeys.Rpc.setType(prop, SupportedRpcType.NETTY);
  return new MiniRaftClusterWithNetty(ids, prop);
}
 

@Override
public SupportedRpcType getRpcType() {
  return SupportedRpcType.NETTY;
}
 

@Override
public MiniRaftClusterWithNetty newCluster(String[] ids, RaftProperties prop) {
  RaftConfigKeys.Rpc.setType(prop, SupportedRpcType.NETTY);
  return new MiniRaftClusterWithNetty(ids, prop);
}
 

@Override
public SupportedRpcType getRpcType() {
  return SupportedRpcType.HADOOP;
}
 

@Override
public SupportedRpcType getRpcType() {
  return SupportedRpcType.HADOOP;
}
 

public MiniRaftClusterWithHadoopRpc newCluster(
    String[] ids, RaftProperties prop, Configuration conf) {
  RaftConfigKeys.Rpc.setType(prop, SupportedRpcType.HADOOP);
  HadoopConfigKeys.Ipc.setAddress(conf, "0.0.0.0:0");
  return new MiniRaftClusterWithHadoopRpc(ids, prop, conf);
}
 

@Override
public SupportedRpcType getRpcType() {
  return SupportedRpcType.GRPC;
}
 

@Override
public SupportedRpcType getRpcType() {
  return SupportedRpcType.GRPC;
}
 

@Override
public MiniRaftClusterWithGrpc newCluster(
    String[] ids, RaftProperties prop) {
  RaftConfigKeys.Rpc.setType(prop, SupportedRpcType.GRPC);
  return new MiniRaftClusterWithGrpc(ids, prop);
}
 

@Override
public SupportedRpcType getRpcType() {
  return SupportedRpcType.NETTY;
}
 

@Override
public SupportedRpcType getRpcType() {
  return SupportedRpcType.NETTY;
}
 

@Override
public MiniRaftClusterWithGrpc newCluster(
    String[] ids, RaftProperties prop) {
  RaftConfigKeys.Rpc.setType(prop, SupportedRpcType.GRPC);
  return new MiniRaftClusterWithGrpc(ids, prop);
}
 

@Override
public SupportedRpcType getRpcType() {
  return SupportedRpcType.GRPC;
}
 

@Override
public SupportedRpcType getRpcType() {
  return SupportedRpcType.GRPC;
}
 

public MiniRaftClusterWithHadoopRpc newCluster(
    String[] ids, RaftProperties prop, Configuration conf) {
  RaftConfigKeys.Rpc.setType(prop, SupportedRpcType.HADOOP);
  HadoopConfigKeys.Ipc.setAddress(conf, "0.0.0.0:0");
  return new MiniRaftClusterWithHadoopRpc(ids, prop, conf);
}
 

@Override
public SupportedRpcType getRpcType() {
  return SupportedRpcType.HADOOP;
}
 

@Override
public SupportedRpcType getRpcType() {
  return SupportedRpcType.HADOOP;
}
 

@Test
public void testBothGetandPutSmallFileRatisGrpc() throws Exception {
  runTestBothGetandPutSmallFileRatis(SupportedRpcType.GRPC, 1);
  runTestBothGetandPutSmallFileRatis(SupportedRpcType.GRPC, 3);
}
 

@Test
public void testBothGetandPutSmallFileRatisNetty() throws Exception {
  runTestBothGetandPutSmallFileRatis(SupportedRpcType.NETTY, 1);
  runTestBothGetandPutSmallFileRatis(SupportedRpcType.NETTY, 3);
}
 

@Test
public void testOzoneContainerViaDataNodeRatisNetty() throws Exception {
  runTestOzoneContainerViaDataNodeRatis(SupportedRpcType.NETTY, 1);
  runTestOzoneContainerViaDataNodeRatis(SupportedRpcType.NETTY, 3);
}
 

@Test
public void testOzoneContainerViaDataNodeRatisGrpc() throws Exception {
  runTestOzoneContainerViaDataNodeRatis(SupportedRpcType.GRPC, 1);
  runTestOzoneContainerViaDataNodeRatis(SupportedRpcType.GRPC, 3);
}
 

@Test
public void testTestRatisManagerNetty() throws Exception {
  runTestRatisManager(SupportedRpcType.NETTY);
}
 

@Test
public void testTestRatisManagerGrpc() throws Exception {
  runTestRatisManager(SupportedRpcType.GRPC);
}