io.atomix.protocols.raft.protocol.ConfigureRequest Java Examples

@Override
public CompletableFuture<ConfigureResponse> onConfigure(ConfigureRequest request) {
  raft.checkThread();
  logRequest(request);
  updateTermAndLeader(request.term(), request.leader());

  Configuration configuration = new Configuration(request.index(), request.term(), request.timestamp(), request.members());

  // Configure the cluster membership. This will cause this server to transition to the
  // appropriate state if its type has changed.
  raft.getCluster().configure(configuration);

  // If the configuration is already committed, commit it to disk.
  // Check against the actual cluster Configuration rather than the received configuration in
  // case the received configuration was an older configuration that was not applied.
  if (raft.getCommitIndex() >= raft.getCluster().getConfiguration().index()) {
    raft.getCluster().commit();
  }

  return CompletableFuture.completedFuture(logResponse(ConfigureResponse.builder()
      .withStatus(RaftResponse.Status.OK)
      .build()));
}
 

/**
 * Handles an OK configuration response.
 */
@SuppressWarnings("unused")
protected void handleConfigureResponseOk(RaftMemberContext member, ConfigureRequest request, ConfigureResponse response) {
  // Reset the member failure count and update the member's status if necessary.
  succeedAttempt(member);

  // Update the member's current configuration term and index according to the installed configuration.
  member.setConfigTerm(request.term());
  member.setConfigIndex(request.index());

  // Recursively append entries to the member.
  appendEntries(member);
}
 

/**
 * Builds a configure request for the given member.
 */
protected ConfigureRequest buildConfigureRequest(RaftMemberContext member) {
  DefaultRaftMember leader = raft.getLeader();
  return ConfigureRequest.builder()
      .withTerm(raft.getTerm())
      .withLeader(leader != null ? leader.memberId() : null)
      .withIndex(raft.getCluster().getConfiguration().index())
      .withTime(raft.getCluster().getConfiguration().time())
      .withMembers(raft.getCluster().getConfiguration().members())
      .build();
}
 

/**
 * Connects to the member and sends a configure request.
 */
protected void sendConfigureRequest(RaftMemberContext member, ConfigureRequest request) {
  log.debug("Configuring {}", member.getMember().memberId());

  // Start the configure to the member.
  member.startConfigure();

  long timestamp = System.currentTimeMillis();

  log.trace("Sending {} to {}", request, member.getMember().memberId());
  raft.getProtocol().configure(member.getMember().memberId(), request).whenCompleteAsync((response, error) -> {
    // Complete the configure to the member.
    member.completeConfigure();

    if (open) {
      if (error == null) {
        log.trace("Received {} from {}", response, member.getMember().memberId());
        handleConfigureResponse(member, request, response, timestamp);
      } else {
        if (log.isTraceEnabled()) {
          log.debug("Failed to configure {}", member.getMember().memberId(), error);
        } else {
          log.debug("Failed to configure {}", member.getMember().memberId());
        }
        handleConfigureResponseFailure(member, request, error);
      }
    }
  }, raft.getThreadContext());
}
 

/**
 * Handles a configuration response.
 */
protected void handleConfigureResponse(RaftMemberContext member, ConfigureRequest request, ConfigureResponse response, long timestamp) {
  if (response.status() == RaftResponse.Status.OK) {
    handleConfigureResponseOk(member, request, response);
  } else {
    handleConfigureResponseError(member, request, response);
  }
}
 

/**
 * Handles a configure failure.
 */
protected void handleConfigureResponseFailure(RaftMemberContext member, ConfigureRequest request, Throwable error) {
  // Log the failed attempt to contact the member.
  failAttempt(member, request, error);
}
 

@Override
public void registerConfigureHandler(Function<ConfigureRequest, CompletableFuture<ConfigureResponse>> handler) {
  this.configureHandler = handler;
}
 

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

@Override
public void registerConfigureHandler(Function<ConfigureRequest, CompletableFuture<ConfigureResponse>> handler) {
  registerHandler("configure", handler);
}
 

@Override
public CompletableFuture<ConfigureResponse> configure(MemberId memberId, ConfigureRequest request) {
  return sendAndReceive(memberId, "configure", request);
}
 

@Override
public CompletableFuture<ConfigureResponse> onConfigure(ConfigureRequest request) {
  CompletableFuture<ConfigureResponse> future = super.onConfigure(request);
  resetHeartbeatTimeout();
  return future;
}
 

@Override
protected void handleConfigureResponse(RaftMemberContext member, ConfigureRequest request, ConfigureResponse response, long timestamp) {
  super.handleConfigureResponse(member, request, response, timestamp);
  recordHeartbeat(member, timestamp);
}
 

/**
 * Handles an ERROR configuration response.
 */
@SuppressWarnings("unused")
protected void handleConfigureResponseError(RaftMemberContext member, ConfigureRequest request, ConfigureResponse response) {
  // In the event of a configure response error, simply do nothing and await the next heartbeat.
  // This prevents infinite loops when cluster configurations fail.
}
 

@Override
public CompletableFuture<ConfigureResponse> configure(MemberId memberId,
                                                      ConfigureRequest request) {
  return sendAndReceive(memberId, "configure", request);
}
 

@Override
public void registerConfigureHandler(Function<ConfigureRequest, CompletableFuture<ConfigureResponse>> handler) {
  clusterCommunicator.subscribe(context.configureSubject, serializer::decode, handler, serializer::encode);
}
 

@Override
public CompletableFuture<ConfigureResponse> configure(MemberId memberId, ConfigureRequest request) {
  return sendAndReceive(context.configureSubject, request, memberId);
}
 

@Override
public void registerConfigureHandler(Function<ConfigureRequest,
    CompletableFuture<ConfigureResponse>> handler) {
  this.configureHandler = handler;
}
 

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

@Override
public void registerConfigureHandler(Function<ConfigureRequest,
    CompletableFuture<ConfigureResponse>> handler) {
  registerHandler("configure", handler);
}
 

@Override
public CompletableFuture<ConfigureResponse> configure(MemberId memberId,
                                                      ConfigureRequest request) {
  return sendAndReceive(memberId, "configure", request);
}
 

@Override
public void registerConfigureHandler(Function<ConfigureRequest,
    CompletableFuture<ConfigureResponse>> handler) {
  this.configureHandler = handler;
}
 

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

@Override
public void registerConfigureHandler(Function<ConfigureRequest,
    CompletableFuture<ConfigureResponse>> handler) {
  registerHandler("configure", handler);
}
 

/**
 * Handles a configure request.
 *
 * @param request The request to handle.
 * @return A completable future to be completed with the request response.
 */
CompletableFuture<ConfigureResponse> onConfigure(ConfigureRequest request);