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

@Override
protected VoteResponse handleVote(VoteRequest request) {
  // Reset the heartbeat timeout if we voted for another candidate.
  VoteResponse response = super.handleVote(request);
  if (response.voted()) {
    resetHeartbeatTimeout();
  }
  return response;
}
 

@Override
public CompletableFuture<VoteResponse> onVote(VoteRequest request) {
  logRequest(request);
  return Futures.completedFuture(logResponse(VoteResponse.builder()
      .withStatus(Status.ERROR)
      .withError(RaftError.Type.UNAVAILABLE)
      .build()));
}
 

@Override
public CompletableFuture<VoteResponse> onVote(final VoteRequest request) {
  if (updateTermAndLeader(request.term(), null)) {
    log.debug("Received greater term");
    raft.transition(RaftServer.Role.FOLLOWER);
    return super.onVote(request);
  } else {
    logRequest(request);
    return CompletableFuture.completedFuture(logResponse(VoteResponse.builder()
        .withStatus(RaftResponse.Status.OK)
        .withTerm(raft.getTerm())
        .withVoted(false)
        .build()));
  }
}
 

@Override
public CompletableFuture<VoteResponse> onVote(VoteRequest request) {
  raft.checkThread();
  logRequest(request);

  // If the request indicates a term that is greater than the current term then
  // assign that term and leader to the current context and step down as a candidate.
  if (updateTermAndLeader(request.term(), null)) {
    CompletableFuture<VoteResponse> future = super.onVote(request);
    raft.transition(RaftServer.Role.FOLLOWER);
    return future;
  }

  // If the vote request is not for this candidate then reject the vote.
  if (request.candidate() == raft.getCluster().getMember().memberId()) {
    return CompletableFuture.completedFuture(logResponse(VoteResponse.builder()
        .withStatus(RaftResponse.Status.OK)
        .withTerm(raft.getTerm())
        .withVoted(true)
        .build()));
  } else {
    return CompletableFuture.completedFuture(logResponse(VoteResponse.builder()
        .withStatus(RaftResponse.Status.OK)
        .withTerm(raft.getTerm())
        .withVoted(false)
        .build()));
  }
}
 

@Override
public CompletableFuture<VoteResponse> onVote(VoteRequest request) {
  raft.checkThread();
  logRequest(request);
  updateTermAndLeader(request.term(), null);

  return CompletableFuture.completedFuture(logResponse(VoteResponse.builder()
      .withStatus(RaftResponse.Status.ERROR)
      .withError(RaftError.Type.ILLEGAL_MEMBER_STATE, "Cannot request vote from RESERVE member")
      .build()));
}
 

@Override
public CompletableFuture<VoteResponse> onVote(VoteRequest request) {
  raft.checkThread();
  logRequest(request);

  // If the request indicates a term that is greater than the current term then
  // assign that term and leader to the current context.
  boolean transition = updateTermAndLeader(request.term(), null);

  CompletableFuture<VoteResponse> future = CompletableFuture.completedFuture(logResponse(handleVote(request)));
  if (transition) {
    raft.transition(RaftServer.Role.FOLLOWER);
  }
  return future;
}
 

/**
 * Handles a vote request.
 */
protected VoteResponse handleVote(VoteRequest request) {
  // If the request term is not as great as the current context term then don't
  // vote for the candidate. We want to vote for candidates that are at least
  // as up to date as us.
  if (request.term() < raft.getTerm()) {
    log.debug("Rejected {}: candidate's term is less than the current term", request);
    return VoteResponse.builder()
        .withStatus(RaftResponse.Status.OK)
        .withTerm(raft.getTerm())
        .withVoted(false)
        .build();
  }
  // If a leader was already determined for this term then reject the request.
  else if (raft.getLeader() != null) {
    log.debug("Rejected {}: leader already exists", request);
    return VoteResponse.builder()
        .withStatus(RaftResponse.Status.OK)
        .withTerm(raft.getTerm())
        .withVoted(false)
        .build();
  }
  // If the requesting candidate is not a known member of the cluster (to this
  // node) then don't vote for it. Only vote for candidates that we know about.
  else if (!raft.getCluster().getRemoteMemberStates().stream().map(m -> m.getMember().memberId()).collect(Collectors.toSet()).contains(request.candidate())) {
    log.debug("Rejected {}: candidate is not known to the local member", request);
    return VoteResponse.builder()
        .withStatus(RaftResponse.Status.OK)
        .withTerm(raft.getTerm())
        .withVoted(false)
        .build();
  }
  // If no vote has been cast, check the log and cast a vote if necessary.
  else if (raft.getLastVotedFor() == null) {
    if (isLogUpToDate(request.lastLogIndex(), request.lastLogTerm(), request)) {
      raft.setLastVotedFor(request.candidate());
      return VoteResponse.builder()
          .withStatus(RaftResponse.Status.OK)
          .withTerm(raft.getTerm())
          .withVoted(true)
          .build();
    } else {
      return VoteResponse.builder()
          .withStatus(RaftResponse.Status.OK)
          .withTerm(raft.getTerm())
          .withVoted(false)
          .build();
    }
  }
  // If we already voted for the requesting server, respond successfully.
  else if (raft.getLastVotedFor() == request.candidate()) {
    log.debug("Accepted {}: already voted for {}", request, raft.getCluster().getMember(raft.getLastVotedFor()).memberId());
    return VoteResponse.builder()
        .withStatus(RaftResponse.Status.OK)
        .withTerm(raft.getTerm())
        .withVoted(true)
        .build();
  }
  // In this case, we've already voted for someone else.
  else {
    log.debug("Rejected {}: already voted for {}", request, raft.getCluster().getMember(raft.getLastVotedFor()).memberId());
    return VoteResponse.builder()
        .withStatus(RaftResponse.Status.OK)
        .withTerm(raft.getTerm())
        .withVoted(false)
        .build();
  }
}
 

@Override
public void registerVoteHandler(Function<VoteRequest, CompletableFuture<VoteResponse>> handler) {
  this.voteHandler = handler;
}
 

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

@Override
public void registerVoteHandler(Function<VoteRequest, CompletableFuture<VoteResponse>> handler) {
  registerHandler("vote", handler);
}
 

@Override
public CompletableFuture<VoteResponse> vote(MemberId memberId, VoteRequest request) {
  return sendAndReceive(memberId, "vote", request);
}
 

@Override
public CompletableFuture<VoteResponse> vote(MemberId memberId, VoteRequest request) {
  return sendAndReceive(memberId, "vote", request);
}
 

@Override
public void registerVoteHandler(Function<VoteRequest, CompletableFuture<VoteResponse>> handler) {
  clusterCommunicator.subscribe(context.voteSubject, serializer::decode, handler, serializer::encode);
}
 

@Override
public CompletableFuture<VoteResponse> vote(MemberId memberId, VoteRequest request) {
  return sendAndReceive(context.voteSubject, request, memberId);
}
 

@Override
public void registerVoteHandler(Function<VoteRequest,
    CompletableFuture<VoteResponse>> handler) {
  this.voteHandler = handler;
}
 

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

@Override
public void registerVoteHandler(Function<VoteRequest,
    CompletableFuture<VoteResponse>> handler) {
  registerHandler("vote", handler);
}
 

@Override
public CompletableFuture<VoteResponse> vote(MemberId memberId, VoteRequest request) {
  return sendAndReceive(memberId, "vote", request);
}
 

@Override
public void registerVoteHandler(Function<VoteRequest,
    CompletableFuture<VoteResponse>> handler) {
  this.voteHandler = handler;
}
 

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

@Override
public void registerVoteHandler(Function<VoteRequest,
    CompletableFuture<VoteResponse>> handler) {
  registerHandler("vote", handler);
}
 

/**
 * Handles a vote request.
 *
 * @param request The request to handle.
 * @return A completable future to be completed with the request response.
 */
CompletableFuture<VoteResponse> onVote(VoteRequest request);