io.atomix.cluster.MemberId Java Examples

@Override
public CompletableFuture<Void> bootstrap(Collection<MemberId> cluster) {
  if (joinFuture != null) {
    return joinFuture;
  }

  if (configuration == null) {
    member.setType(RaftMember.Type.ACTIVE);

    // Create a set of active members.
    Set<RaftMember> activeMembers = cluster.stream()
        .filter(m -> !m.equals(member.memberId()))
        .map(m -> new DefaultRaftMember(m, RaftMember.Type.ACTIVE, member.getLastUpdated()))
        .collect(Collectors.toSet());

    // Add the local member to the set of active members.
    activeMembers.add(member);

    // Create a new configuration and store it on disk to ensure the cluster can fall back to the configuration.
    configure(new Configuration(0, 0, member.getLastUpdated().toEpochMilli(), activeMembers));
  }
  return join();
}
 

/**
 * Forwards the given request to the leader if possible.
 */
protected <T extends RaftRequest, U extends RaftResponse> CompletableFuture<U> forward(T request, BiFunction<MemberId, T, CompletableFuture<U>> function) {
  CompletableFuture<U> future = new CompletableFuture<>();
  DefaultRaftMember leader = raft.getLeader();
  if (leader == null) {
    return Futures.exceptionalFuture(new RaftException.NoLeader("No leader found"));
  }

  function.apply(leader.memberId(), request).whenCompleteAsync((response, error) -> {
    if (error == null) {
      future.complete(response);
    } else {
      future.completeExceptionally(error);
    }
  }, raft.getThreadContext());
  return future;
}
 

public DefaultRaftClient(
    String clientId,
    PartitionId partitionId,
    MemberId memberId,
    Collection<MemberId> cluster,
    RaftClientProtocol protocol,
    ThreadContextFactory threadContextFactory,
    boolean closeThreadFactoryOnClose) {
  this.clientId = checkNotNull(clientId, "clientId cannot be null");
  this.partitionId = checkNotNull(partitionId, "partitionId cannot be null");
  this.cluster = checkNotNull(cluster, "cluster cannot be null");
  this.protocol = checkNotNull(protocol, "protocol cannot be null");
  this.threadContextFactory = checkNotNull(threadContextFactory, "threadContextFactory cannot be null");
  this.threadContext = threadContextFactory.createContext();
  this.metadata = new DefaultRaftMetadataClient(clientId, protocol, selectorManager, threadContextFactory.createContext());
  this.sessionManager = new RaftSessionManager(clientId, memberId, protocol, selectorManager, threadContextFactory);
  this.closeThreadFactoryOnClose = closeThreadFactoryOnClose;
}
 

/**
 * Registers the consumer with the given leader.
 *
 * @param leader the leader with which to register the consumer
 */
private CompletableFuture<Void> register(MemberId leader) {
  CompletableFuture<Void> future = new CompletableFuture<>();
  this.leader = leader;
  protocol.consume(leader, ConsumeRequest.request(memberId, subject, index + 1))
      .whenCompleteAsync((response, error) -> {
        if (error == null) {
          if (response.status() == LogResponse.Status.OK) {
            future.complete(null);
          } else {
            future.completeExceptionally(new PrimitiveException.Unavailable());
          }
        } else {
          future.completeExceptionally(error);
        }
      }, threadContext);
  return future;
}
 

public RaftPartitionClient(
    RaftPartition partition,
    MemberId localMemberId,
    RaftClientProtocol protocol,
    ThreadContextFactory threadContextFactory) {
  this.partition = partition;
  this.localMemberId = localMemberId;
  this.protocol = protocol;
  this.threadContextFactory = threadContextFactory;
}
 

@Override
public CompletableFuture<Void> replicate(BackupOperation operation) {
  for (MemberId backup : context.backups()) {
    queues.computeIfAbsent(backup, BackupQueue::new).add(operation);
  }
  context.setCommitIndex(operation.index());
  return CompletableFuture.completedFuture(null);
}
 

private CompletableFuture<TestRaftServerProtocol> getServer(MemberId memberId) {
  TestRaftServerProtocol server = server(memberId);
  if (server != null) {
    return Futures.completedFuture(server);
  } else {
    return Futures.exceptionalFuture(new ConnectException());
  }
}
 

/**
 * Recursively recovers transactions using the given iterator.
 *
 * @param iterator the asynchronous iterator from which to recover transactions
 * @param memberId the transaction member ID
 */
private void recoverTransactions(AsyncIterator<Map.Entry<TransactionId, Versioned<TransactionInfo>>> iterator, MemberId memberId) {
  iterator.next().thenAccept(entry -> {
    if (entry.getValue().value().coordinator.equals(memberId)) {
      recoverTransaction(entry.getKey(), entry.getValue().value());
    }
    recoverTransactions(iterator, memberId);
  });
}
 

/**
 * Tests selecting members using the FOLLOWER selector.
 */
@Test
public void testSelectFollower() throws Exception {
  MemberSelectorManager selectorManager = new MemberSelectorManager();
  MemberSelector selector = selectorManager.createSelector(CommunicationStrategy.FOLLOWERS);

  assertNull(selector.leader());
  assertFalse(selector.hasNext());

  selectorManager.resetAll(null, Arrays.asList(MemberId.from("a"), MemberId.from("b"), MemberId.from("c")));
  assertNull(selector.leader());
  assertTrue(selector.hasNext());
  assertNotNull(selector.next());
  assertNotNull(selector.next());
  assertNotNull(selector.next());
  assertFalse(selector.hasNext());
  selector.reset();
  assertTrue(selector.hasNext());
  assertNotNull(selector.next());
  assertNotNull(selector.next());
  assertNotNull(selector.next());
  assertFalse(selector.hasNext());

  selectorManager.resetAll(MemberId.from("a"), Arrays.asList(MemberId.from("a"), MemberId.from("b"), MemberId.from("c")));
  assertNotNull(selector.leader());
  assertTrue(selector.hasNext());
  assertNotNull(selector.next());
  assertNotNull(selector.next());
  assertFalse(selector.hasNext());
}
 

private RaftServer createServer(MemberId memberId, Function<RaftServer.Builder, RaftServer.Builder> configurator) {
  final RaftServer.Builder defaults =
      RaftServer.builder(memberId)
          .withMembershipService(mock(ClusterMembershipService.class))
          .withProtocol(protocolFactory.newServerProtocol(memberId));
  final RaftServer server = configurator.apply(defaults).build();

  servers.add(server);
  return server;
}
 

/**
 * Returns a new Raft server builder using the default host:port.
 * <p>
 * The server will be constructed at 0.0.0.0:8700.
 *
 * @return The server builder.
 */
static Builder builder() {
  try {
    InetAddress address = InetAddress.getByName("0.0.0.0");
    return builder(MemberId.from(address.getHostName()));
  } catch (UnknownHostException e) {
    throw new ConfigurationException("Cannot configure local node", e);
  }
}
 

protected <T, U> CompletableFuture<U> sendAndReceive(MemberId memberId,
                                                     String type, T request) {
  Address address = address(memberId);
  if (address == null) {
    return Futures.exceptionalFuture(new ConnectException());
  }
  return messagingService.sendAndReceive(address, type, serializer.encode(request))
      .thenApply(serializer::decode);
}
 

private CompletableFuture<TestPrimaryBackupServerProtocol> getServer(MemberId memberId) {
  TestPrimaryBackupServerProtocol server = server(memberId);
  if (server != null) {
    return Futures.completedFuture(server);
  } else {
    return Futures.exceptionalFuture(new ConnectException());
  }
}
 

/**
 * Applies an open session entry to the state machine.
 */
private long applyOpenSession(Indexed<OpenSessionEntry> entry) {
  PrimitiveType primitiveType = raft.getPrimitiveTypes().getPrimitiveType(entry.entry().serviceType());

  // Get the state machine executor or create one if it doesn't already exist.
  RaftServiceContext service = getOrInitializeService(
      PrimitiveId.from(entry.index()),
      primitiveType,
      entry.entry().serviceName(),
      entry.entry().serviceConfig());

  if (service == null) {
    throw new RaftException.UnknownService("Unknown service type " + entry.entry().serviceType());
  }

  SessionId sessionId = SessionId.from(entry.index());
  RaftSession session = raft.getSessions().addSession(new RaftSession(
      sessionId,
      MemberId.from(entry.entry().memberId()),
      entry.entry().serviceName(),
      primitiveType,
      entry.entry().readConsistency(),
      entry.entry().minTimeout(),
      entry.entry().maxTimeout(),
      entry.entry().timestamp(),
      service.serializer(),
      service,
      raft,
      threadContextFactory));
  return service.openSession(entry.index(), entry.entry().timestamp(), session);
}
 

@Override
public CompletableFuture<QueryResponse> query(MemberId memberId, QueryRequest request) {
  return sendAndReceive(memberId, "query", request);
}
 

@Override
public CompletableFuture<CloseSessionResponse> closeSession(MemberId memberId,
                                                            CloseSessionRequest request) {
  return sendAndReceive(memberId, "close-session", request);
}
 

@Override
public CompletableFuture<MetadataResponse> metadata(MemberId memberId, MetadataRequest request) {
  return sendAndReceive(context.metadataSubject, request, memberId);
}
 

public HeartbeatRequest(MemberId leader, Collection<MemberId> members) {
  this.leader = leader;
  this.members = members;
}
 

@Override
public CompletableFuture<OpenSessionResponse> openSession(MemberId memberId, OpenSessionRequest request) {
  return sendAndReceive(context.openSessionSubject, request, memberId);
}
 

@Override
public CompletableFuture<ConfigureResponse> configure(MemberId memberId,
                                                      ConfigureRequest request) {
  return getServer(memberId).thenCompose(listener ->
      listener.configure(encode(request))).thenApply(this::decode);
}
 

@Override
public CompletableFuture<OpenSessionResponse> openSession(MemberId memberId, OpenSessionRequest request) {
  return getServer(memberId).thenCompose(protocol -> protocol.openSession(encode(request))).thenApply(this::decode);
}
 

public static ResetRequest request(MemberId memberId, String subject, long index) {
  return new ResetRequest(memberId, subject, index);
}
 

public MemberId memberId() {
  return memberId;
}
 

public MemberId memberId() {
  return memberId;
}
 

@Override
public CompletableFuture<QueryResponse> query(MemberId memberId, QueryRequest request) {
  return sendAndReceive(memberId, "query", request);
}
 

public TestLogServerProtocol(MemberId memberId, Map<MemberId, TestLogServerProtocol> servers, Map<MemberId, TestLogClientProtocol> clients) {
  super(servers, clients);
  servers.put(memberId, this);
}
 

@Override
public CompletableFuture<CommandResponse> command(MemberId memberId, CommandRequest request) {
  return getServer(memberId).thenCompose(protocol -> protocol.command(encode(request))).thenApply(this::decode);
}
 

@Override
public void reset(MemberId memberId, ResetRequest request) {
  unicast(context.resetSubject, request, memberId);
}
 

protected Builder(MemberId localMemberId) {
  this.localMemberId = checkNotNull(localMemberId, "localMemberId cannot be null");
}
 

public LocalRaftServerProtocol(MemberId memberId, Serializer serializer, Map<MemberId, LocalRaftServerProtocol> servers, Map<MemberId, LocalRaftClientProtocol> clients) {
  super(serializer, servers, clients);
  servers.put(memberId, this);
}