org.apache.ratis.proto.RaftProtos.RequestVoteReplyProto Java Examples

public static RequestVoteReplyProto requestVote(RaftPeerId raftPeerId,
    RequestVoteRequestProto request) {
  addLatency();
  System.out.println("Request vote response");
  return RequestVoteReplyProto.newBuilder()
      .setServerReply(
          RaftRpcReplyProto.newBuilder()
              .setSuccess(true)
              .setRequestorId(request.getServerRequest().getRequestorId())
              .setReplyId(raftPeerId.toByteString())
              .setCallId(request.getServerRequest().getCallId())
              .setRaftGroupId(request.getServerRequest().getRaftGroupId())
      )
      .setTerm(request.getCandidateTerm())
      .build();
}
 

/**
 * Pseudo sync call to request a vote.
 *
 */
private CompletableFuture<RequestVoteReplyProto> requestVote() {
  CompletableFuture<RequestVoteReplyProto> response =
      new CompletableFuture<>();
  RequestVoteRequestProto voteRequest = RequestVoteRequestProto.newBuilder()
      .setServerRequest(createServerRequest(callIdRandom.nextLong()))
      .setCandidateLastEntry(
          TermIndexProto.newBuilder()
              .setIndex(0L)
              .setTerm(term)
              .build()
      )
      .build();

  stub.requestVote(voteRequest,
      new StreamObserver<RequestVoteReplyProto>() {
        @Override
        public void onNext(RequestVoteReplyProto value) {
          response.complete(value);
        }

        @Override
        public void onError(Throwable t) {
          response.completeExceptionally(t);
        }

        @Override
        public void onCompleted() {

        }
      });
  return response;
}
 

@Override
public RequestVoteReplyProto requestVote(
    RpcController unused, RequestVoteRequestProto request)
    throws ServiceException {
  try {
    return impl.requestVote(request);
  } catch(IOException ioe) {
    throw new ServiceException(ioe);
  }
}
 

private ResultAndTerm logAndReturn(Result result,
    Map<RaftPeerId, RequestVoteReplyProto> responses,
    List<Exception> exceptions, long newTerm) {
  LOG.info(this + ": Election " + result + "; received " + responses.size() + " response(s) "
      + responses.values().stream().map(ServerProtoUtils::toString).collect(Collectors.toList())
      + " and " + exceptions.size() + " exception(s); " + server.getState());
  int i = 0;
  for(Exception e : exceptions) {
    final int j = i++;
    LogUtils.infoOrTrace(LOG, () -> "  Exception " + j, e);
  }
  return new ResultAndTerm(result, newTerm);
}
 

private ResultAndTerm logAndReturn(Result result,
    List<RequestVoteReplyProto> responses,
    List<Exception> exceptions, long newTerm) {
  LOG.info(server.getId() + ": Election " + result + "; received "
      + responses.size() + " response(s) "
      + responses.stream().map(ProtoUtils::toString).collect(Collectors.toList())
      + " and " + exceptions.size() + " exception(s); " + server.getState());
  int i = 0;
  for(Exception e : exceptions) {
    LOG.info("  " + i++ + ": " + e);
    LOG.trace("TRACE", e);
  }
  return new ResultAndTerm(result, newTerm);
}
 

@Override
public RequestVoteReplyProto requestVote(
    RpcController unused, RequestVoteRequestProto request)
    throws ServiceException {
  try {
    return impl.requestVote(request);
  } catch(IOException ioe) {
    throw new ServiceException(ioe);
  }
}
 

@Override
public RequestVoteReplyProto requestVote(RequestVoteRequestProto request)
    throws IOException {
  RaftServerReply reply = serverHandler.getRpc()
      .sendRequest(new RaftServerRequest(request));
  return reply.getRequestVote();
}
 

RequestVoteReplyProto getRequestVote() {
  return requestVote;
}
 

RaftServerReply(RequestVoteReplyProto r) {
  appendEntries = null;
  requestVote = Objects.requireNonNull(r);
  installSnapshot = null;
}
 

private ResultAndTerm waitForResults(final long electionTerm,
    final int submitted) throws InterruptedException {
  final Timestamp timeout = Timestamp.currentTime().addTimeMs(server.getRandomTimeoutMs());
  final List<RequestVoteReplyProto> responses = new ArrayList<>();
  final List<Exception> exceptions = new ArrayList<>();
  int waitForNum = submitted;
  Collection<RaftPeerId> votedPeers = new ArrayList<>();
  while (waitForNum > 0 && running && server.isCandidate()) {
    final long waitTime = -timeout.elapsedTimeMs();
    if (waitTime <= 0) {
      return logAndReturn(Result.TIMEOUT, responses, exceptions, -1);
    }

    try {
      final Future<RequestVoteReplyProto> future = service.poll(
          waitTime, TimeUnit.MILLISECONDS);
      if (future == null) {
        continue; // poll timeout, continue to return Result.TIMEOUT
      }

      final RequestVoteReplyProto r = future.get();
      responses.add(r);
      if (r.getShouldShutdown()) {
        return logAndReturn(Result.SHUTDOWN, responses, exceptions, -1);
      }
      if (r.getTerm() > electionTerm) {
        return logAndReturn(Result.DISCOVERED_A_NEW_TERM, responses,
            exceptions, r.getTerm());
      }
      if (r.getServerReply().getSuccess()) {
        votedPeers.add(RaftPeerId.valueOf(r.getServerReply().getReplyId()));
        if (conf.hasMajority(votedPeers, server.getId())) {
          return logAndReturn(Result.PASSED, responses, exceptions, -1);
        }
      }
    } catch(ExecutionException e) {
      LOG.info("{} got exception when requesting votes: {}", server.getId(), e);
      LOG.trace("TRACE", e);
      exceptions.add(e);
    }
    waitForNum--;
  }
  // received all the responses
  return logAndReturn(Result.REJECTED, responses, exceptions, -1);
}
 

@Override
public RequestVoteReplyProto requestVote(RequestVoteRequestProto request) throws IOException {
  return getImpl(request.getServerRequest()).requestVote(request);
}
 

@Override
public RequestVoteReplyProto requestVote(
    RequestVoteRequestProto request) throws IOException {
  return processRequest(request, request.getServerRequest().getReplyId(),
      proxy -> proxy.requestVote(null, request));
}
 

static String toString(RequestVoteReplyProto proto) {
  return toString(proto.getServerReply()) + "-t" + proto.getTerm();
}
 

RequestVoteReplyProto getRequestVote() {
  return requestVote;
}
 

RaftServerReply(RequestVoteReplyProto r) {
  appendEntries = null;
  requestVote = Objects.requireNonNull(r);
  installSnapshot = null;
}
 

private ResultAndTerm waitForResults(final long electionTerm, final int submitted,
    RaftConfiguration conf, Executor voteExecutor) throws InterruptedException {
  final Timestamp timeout = Timestamp.currentTime().addTimeMs(server.getRandomTimeoutMs());
  final Map<RaftPeerId, RequestVoteReplyProto> responses = new HashMap<>();
  final List<Exception> exceptions = new ArrayList<>();
  int waitForNum = submitted;
  Collection<RaftPeerId> votedPeers = new ArrayList<>();
  while (waitForNum > 0 && shouldRun(electionTerm)) {
    final TimeDuration waitTime = timeout.elapsedTime().apply(n -> -n);
    if (waitTime.isNonPositive()) {
      return logAndReturn(Result.TIMEOUT, responses, exceptions, -1);
    }

    try {
      final Future<RequestVoteReplyProto> future = voteExecutor.poll(waitTime);
      if (future == null) {
        continue; // poll timeout, continue to return Result.TIMEOUT
      }

      final RequestVoteReplyProto r = future.get();
      final RaftPeerId replierId = RaftPeerId.valueOf(r.getServerReply().getReplyId());
      final RequestVoteReplyProto previous = responses.putIfAbsent(replierId, r);
      if (previous != null) {
        if (LOG.isWarnEnabled()) {
          LOG.warn("{} received duplicated replies from {}, the 2nd reply is ignored: 1st={}, 2nd={}",
              this, replierId, ServerProtoUtils.toString(previous), ServerProtoUtils.toString(r));
        }
        continue;
      }
      if (r.getShouldShutdown()) {
        return logAndReturn(Result.SHUTDOWN, responses, exceptions, -1);
      }
      if (r.getTerm() > electionTerm) {
        return logAndReturn(Result.DISCOVERED_A_NEW_TERM, responses,
            exceptions, r.getTerm());
      }
      if (r.getServerReply().getSuccess()) {
        votedPeers.add(replierId);
        if (conf.hasMajority(votedPeers, server.getId())) {
          return logAndReturn(Result.PASSED, responses, exceptions, -1);
        }
      }
    } catch(ExecutionException e) {
      LogUtils.infoOrTrace(LOG, () -> this + " got exception when requesting votes", e);
      exceptions.add(e);
    }
    waitForNum--;
  }
  // received all the responses
  return logAndReturn(Result.REJECTED, responses, exceptions, -1);
}
 

Future<RequestVoteReplyProto> poll(TimeDuration waitTime) throws InterruptedException {
  return service.poll(waitTime.getDuration(), waitTime.getUnit());
}
 

void submit(Callable<RequestVoteReplyProto> task) {
  service.submit(task);
}
 

@Override
public RequestVoteReplyProto requestVote(RequestVoteRequestProto request) throws IOException {
  return getImpl(request.getServerRequest()).requestVote(request);
}
 

@Override
public RequestVoteReplyProto requestVote(
    RequestVoteRequestProto request) throws IOException {
  return processRequest(request, request.getServerRequest().getReplyId(),
      proxy -> proxy.requestVote(null, request));
}
 

RequestVoteReplyProto requestVote(RequestVoteRequestProto request) throws IOException; 

RequestVoteReplyProto requestVote(RequestVoteRequestProto request) throws IOException;