How to use

builder

method

in

io.atomix.protocols.raft.RaftClient

/**
 * Returns a new Raft client builder.
 * <p>
 * The provided set of members will be used to connect to the Raft cluster. The members list does not have to represent
 * the complete list of servers in the cluster, but it must have at least one reachable member that can communicate with
 * the cluster's leader.
 *
 * @return The client builder.
 */
@SuppressWarnings("unchecked")
static Builder builder() {
 return builder(Collections.EMPTY_LIST);
}

/**
 * Returns a new Raft client builder.
 * <p>
 * The provided set of members will be used to connect to the Raft cluster. The members list does not have to represent
 * the complete list of servers in the cluster, but it must have at least one reachable member that can communicate with
 * the cluster's leader.
 *
 * @param cluster The cluster to which to connect.
 * @return The client builder.
 */
static Builder builder(MemberId... cluster) {
 return builder(Arrays.asList(cluster));
}

/**
 * Creates a Raft client.
 */
private RaftClient createClient() throws Exception {
 MemberId memberId = nextNodeId();
 RaftClientProtocol protocol;
 if (USE_NETTY) {
  Address address = Address.from(++port);
  MessagingService messagingManager = new NettyMessagingService("test", address, new MessagingConfig()).start().join();
  addressMap.put(memberId, address);
  protocol = new RaftClientMessagingProtocol(messagingManager, PROTOCOL_SERIALIZER, addressMap::get);
 } else {
  protocol = protocolFactory.newClientProtocol(memberId);
 }
 RaftClient client = RaftClient.builder()
   .withMemberId(memberId)
   .withProtocol(protocol)
   .build();
 client.connect(members.stream().map(RaftMember::memberId).collect(Collectors.toList())).join();
 clients.add(client);
 return client;
}

 @Override
 public void run() {
  LOGGER.info("RaftClientThread run() >>>");
  int raftClientPort = 0;
  try {
   raftClientPort = RemoteInterpreterUtils.findRandomAvailablePortOnAllLocalInterfaces();
  } catch (IOException e) {
   LOGGER.error(e.getMessage());
  }
  MemberId memberId = MemberId.from(ZEPL_CLIENT_ID + zeplServerHost + ":" + raftClientPort);
  Address address = Address.from(zeplServerHost, raftClientPort);
  raftAddressMap.put(memberId, address);
  MessagingService messagingManager
    = NettyMessagingService.builder().withAddress(address).build().start().join();
  RaftClientProtocol protocol = new RaftClientMessagingProtocol(
    messagingManager, protocolSerializer, raftAddressMap::get);
  raftClient = RaftClient.builder()
    .withMemberId(memberId)
    .withPartitionId(PartitionId.from("partition", 1))
    .withProtocol(protocol)
    .build();
  raftClient.connect(clusterMemberIds).join();
  raftSessionClient = createProxy(raftClient);
  LOGGER.info("RaftClientThread run() <<<");
 }
}).start();

/**
 * Creates a Raft client.
 */
private RaftClient createClient() throws Exception {
 Member member = nextNode();
 RaftClientProtocol protocol;
 if (USE_NETTY) {
  MessagingService messagingService = new NettyMessagingService("test", member.address(), new MessagingConfig()).start().join();
  protocol = new RaftClientMessagingProtocol(messagingService, PROTOCOL_SERIALIZER, addressMap::get);
 } else {
  protocol = protocolFactory.newClientProtocol(member.id());
 }
 RaftClient client = RaftClient.builder()
   .withMemberId(member.id())
   .withPartitionId(PartitionId.from("test", 1))
   .withProtocol(protocol)
   .withThreadModel(ThreadModel.SHARED_THREAD_POOL)
   .build();
 client.connect(members.stream().map(Member::id).collect(Collectors.toList())).join();
 clients.add(client);
 return client;
}

 private RaftClient newRaftClient(RaftClientProtocol protocol) {
  return RaftClient.builder()
    .withClientId(partition.name())
    .withPartitionId(partition.id())
    .withMemberId(localMemberId)
    .withProtocol(protocol)
    .withThreadContextFactory(threadContextFactory)
    .build();
 }
}