io.atomix.cluster.messaging.MessagingService Java Examples

/**
 * 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;
}
 

/**
 * Creates a Raft server.
 */
private RaftServer createServer(RaftMember member) {
  RaftServerProtocol protocol;
  if (USE_NETTY) {
    Address address = Address.from(++port);
    MessagingService messagingManager = new NettyMessagingService("test", address, new MessagingConfig()).start().join();
    messagingServices.add(messagingManager);
    addressMap.put(member.memberId(), address);
    protocol = new RaftServerMessagingProtocol(messagingManager, PROTOCOL_SERIALIZER, addressMap::get);
  } else {
    protocol = protocolFactory.newServerProtocol(member.memberId());
  }

  RaftServer.Builder builder = RaftServer.builder(member.memberId())
      .withProtocol(protocol)
      .withStorage(RaftStorage.builder()
          .withStorageLevel(StorageLevel.DISK)
          .withDirectory(new File(String.format("target/fuzz-logs/%s", member.memberId())))
          .withNamespace(STORAGE_NAMESPACE)
          .withMaxSegmentSize(1024 * 1024)
          .build());

  RaftServer server = builder.build();
  servers.add(server);
  return server;
}
 

/**
 * 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 CompletableFuture<MessagingService> start() {
  if (started.get()) {
    log.warn("Already running at local address: {}", returnAddress);
    return CompletableFuture.completedFuture(this);
  }

  enableNettyTls = loadKeyStores();
  initEventLoopGroup();
  return bootstrapServer().thenRun(() -> {
    timeoutExecutor = Executors.newScheduledThreadPool(
        4, namedThreads("netty-messaging-timeout-%d", log));
    localConnection = new LocalClientConnection(timeoutExecutor, handlers);
    started.set(true);
    log.info("Started");
  }).thenApply(v -> this);
}
 

public RaftMessagingProtocol(MessagingService messagingService,
                             Serializer serializer,
                             Function<MemberId, Address> addressProvider) {
  this.messagingService = messagingService;
  this.serializer = serializer;
  this.addressProvider = addressProvider;
}
 

public RaftMessagingProtocol(MessagingService messagingService,
                             Serializer serializer,
                             Function<MemberId, Address> addressProvider) {
  this.messagingService = messagingService;
  this.serializer = serializer;
  this.addressProvider = addressProvider;
}
 

public DefaultClusterCommunicationService(
    ClusterMembershipService membershipService,
    MessagingService messagingService,
    UnicastService unicastService) {
  this.membershipService = checkNotNull(membershipService, "clusterService cannot be null");
  this.messagingService = checkNotNull(messagingService, "messagingService cannot be null");
  this.unicastService = checkNotNull(unicastService, "unicastService cannot be null");
}
 

@Override
public CompletableFuture<MessagingService> start() {
  services.put(address, this);
  started.set(true);
  return CompletableFuture.completedFuture(this);
}
 

@Override
public CompletableFuture<MessagingService> start() {
  services.put(address, this);
  started.set(true);
  return CompletableFuture.completedFuture(this);
}
 

@Override
public MessagingService getMessagingService() {
  return messagingService;
}
 

public TestBootstrapService(MessagingService messagingService, UnicastService unicastService, BroadcastService broadcastService) {
  this.messagingService = messagingService;
  this.unicastService = unicastService;
  this.broadcastService = broadcastService;
}
 

/**
 * Builds a cluster event service.
 */
protected static ManagedClusterEventService buildClusterEventService(
    ClusterMembershipService membershipService, MessagingService messagingService) {
  return new DefaultClusterEventService(membershipService, messagingService);
}
 

/**
 * Builds a cluster messaging service.
 */
protected static ManagedClusterCommunicationService buildClusterMessagingService(
    ClusterMembershipService membershipService, MessagingService messagingService, UnicastService unicastService) {
  return new DefaultClusterCommunicationService(membershipService, messagingService, unicastService);
}
 

public DefaultClusterEventService(ClusterMembershipService membershipService, MessagingService messagingService) {
  this.membershipService = membershipService;
  this.messagingService = messagingService;
  this.localMemberId = membershipService.getLocalMember().id();
}
 

public RaftServerMessagingProtocol(MessagingService messagingService, Serializer serializer, Function<MemberId, Address> addressProvider) {
  super(messagingService, serializer, addressProvider);
}
 

public RaftClientMessagingProtocol(MessagingService messagingService, Serializer serializer, Function<MemberId, Address> addressProvider) {
  super(messagingService, serializer, addressProvider);
}
 

public RaftMessagingProtocol(MessagingService messagingService, Serializer serializer, Function<MemberId, Address> addressProvider) {
  this.messagingService = messagingService;
  this.serializer = serializer;
  this.addressProvider = addressProvider;
}
 

/**
 * Creates a Raft server.
 */
private RaftServer createServer(Member member, List<Node> members) {
  RaftServerProtocol protocol;
  ManagedMessagingService messagingService;
  if (USE_NETTY) {
    messagingService = (ManagedMessagingService) new NettyMessagingService("test", member.address(), new MessagingConfig())
        .start()
        .join();
    messagingServices.add(messagingService);
    protocol = new RaftServerMessagingProtocol(messagingService, PROTOCOL_SERIALIZER, addressMap::get);
  } else {
    protocol = protocolFactory.newServerProtocol(member.id());
  }

  BootstrapService bootstrapService = new BootstrapService() {
    @Override
    public MessagingService getMessagingService() {
      return messagingService;
    }

    @Override
    public UnicastService getUnicastService() {
      return new UnicastServiceAdapter();
    }

    @Override
    public BroadcastService getBroadcastService() {
      return new BroadcastServiceAdapter();
    }
  };

  RaftServer.Builder builder = RaftServer.builder(member.id())
      .withProtocol(protocol)
      .withThreadModel(ThreadModel.SHARED_THREAD_POOL)
      .withMembershipService(new DefaultClusterMembershipService(
          member,
          Version.from("1.0.0"),
          new DefaultNodeDiscoveryService(bootstrapService, member, new BootstrapDiscoveryProvider(members)),
          bootstrapService,
          new HeartbeatMembershipProtocol(new HeartbeatMembershipProtocolConfig())))
      .withStorage(RaftStorage.builder()
          .withStorageLevel(StorageLevel.DISK)
          .withDirectory(new File(String.format("target/perf-logs/%s", member.id())))
          .withNamespace(STORAGE_NAMESPACE)
          .withMaxSegmentSize(1024 * 1024 * 64)
          .withDynamicCompaction()
          .withFlushOnCommit(false)
          .build());

  RaftServer server = builder.build();
  servers.add(server);
  return server;
}
 

public RaftServerMessagingProtocol(MessagingService messagingService,
                                   Serializer serializer,
                                   Function<MemberId, Address> addressProvider) {
  super(messagingService, serializer, addressProvider);
}
 

public RaftClientMessagingProtocol(MessagingService messagingService,
                                   Serializer serializer,
                                   Function<MemberId, Address> addressProvider) {
  super(messagingService, serializer, addressProvider);
}
 

public RaftServerMessagingProtocol(MessagingService messagingService,
                                   Serializer serializer,
                                   Function<MemberId, Address> addressProvider) {
  super(messagingService, serializer, addressProvider);
}
 

public RaftClientMessagingProtocol(MessagingService messagingService,
                                   Serializer serializer,
                                   Function<MemberId, Address> addressProvider) {
  super(messagingService, serializer, addressProvider);
}
 

/**
 * Returns the cluster messaging service.
 *
 * @return the cluster messaging service
 */
MessagingService getMessagingService();
 

/**
 * Returns the cluster messaging service.
 * <p>
 * The messaging service is used for direct point-to-point messaging between nodes by {@link Address}. This is a
 * low-level cluster communication API. For higher level messaging, use the
 * {@link #getCommunicationService() communication service} or {@link #getEventService() event service}.
 *
 * @return the cluster messaging service
 */
@Override
public MessagingService getMessagingService() {
  return messagingService;
}