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

@Override
public CompletableFuture<LeaveResponse> onLeave(LeaveRequest request) {
  raft.checkThread();
  logRequest(request);

  if (raft.getLeader() == null) {
    return CompletableFuture.completedFuture(logResponse(LeaveResponse.builder()
        .withStatus(RaftResponse.Status.ERROR)
        .withError(RaftError.Type.NO_LEADER)
        .build()));
  } else {
    return forward(request, raft.getProtocol()::leave)
        .exceptionally(error -> LeaveResponse.builder()
            .withStatus(RaftResponse.Status.ERROR)
            .withError(RaftError.Type.NO_LEADER)
            .build())
        .thenApply(this::logResponse);
  }
}
 

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

/**
 * Attempts to leave the cluster.
 */
private void leave(CompletableFuture<Void> future) {
  // Set a timer to retry the attempt to leave the cluster.
  leaveTimeout = raft.getThreadContext().schedule(raft.getElectionTimeout(), () -> {
    leave(future);
  });

  // Attempt to leave the cluster by submitting a LeaveRequest directly to the server state.
  // Non-leader states should forward the request to the leader if there is one. Leader states
  // will log, replicate, and commit the reconfiguration.
  raft.getRaftRole().onLeave(LeaveRequest.builder()
      .withMember(getMember())
      .build()).whenComplete((response, error) -> {
        // Cancel the leave timer.
        cancelLeaveTimer();

        if (error == null && response.status() == RaftResponse.Status.OK) {
          Configuration configuration = new Configuration(response.index(), response.term(), response.timestamp(), response.members());

          // Configure the cluster and commit the configuration as we know the successful response
          // indicates commitment.
          configure(configuration).commit();
          future.complete(null);
        } else {
          // Reset the leave timer.
          leaveTimeout = raft.getThreadContext().schedule(raft.getElectionTimeout(), () -> {
            leave(future);
          });
        }
      });
}
 

@Override
public void registerLeaveHandler(Function<LeaveRequest, CompletableFuture<LeaveResponse>> handler) {
  clusterCommunicator.subscribe(context.leaveSubject, serializer::decode, handler, serializer::encode);
}
 

@Override
public void registerLeaveHandler(Function<LeaveRequest, CompletableFuture<LeaveResponse>> handler) {
  this.leaveHandler = handler;
}
 

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

@Override
public void registerLeaveHandler(Function<LeaveRequest, CompletableFuture<LeaveResponse>> handler) {
  registerHandler("leave", handler);
}
 

@Override
public CompletableFuture<LeaveResponse> leave(MemberId memberId, LeaveRequest request) {
  return sendAndReceive(memberId, "leave", request);
}
 

@Override
public CompletableFuture<LeaveResponse> leave(MemberId memberId, LeaveRequest request) {
  return sendAndReceive(memberId, "leave", request);
}
 

@Override
public CompletableFuture<LeaveResponse> leave(MemberId memberId, LeaveRequest request) {
  return sendAndReceive(context.leaveSubject, request, memberId);
}
 

@Override
public void registerLeaveHandler(Function<LeaveRequest,
    CompletableFuture<LeaveResponse>> handler) {
  this.leaveHandler = handler;
}
 

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

@Override
public void registerLeaveHandler(Function<LeaveRequest,
    CompletableFuture<LeaveResponse>> handler) {
  registerHandler("leave", handler);
}
 

@Override
public CompletableFuture<LeaveResponse> leave(MemberId memberId, LeaveRequest request) {
  return sendAndReceive(memberId, "leave", request);
}
 

@Override
public void registerLeaveHandler(Function<LeaveRequest,
    CompletableFuture<LeaveResponse>> handler) {
  this.leaveHandler = handler;
}
 

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

@Override
public void registerLeaveHandler(Function<LeaveRequest,
    CompletableFuture<LeaveResponse>> handler) {
  registerHandler("leave", handler);
}
 

/**
 * Handles a leave request.
 *
 * @param request The request to handle.
 * @return A completable future to be completed with the request response.
 */
CompletableFuture<LeaveResponse> onLeave(LeaveRequest request);