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

@Override
public void reset(Set<MemberId> members, ResetRequest request) {
  members.forEach(nodeId -> {
    LocalRaftServerProtocol server = server(nodeId);
    if (server != null) {
      server.reset(request.session(), encode(request));
    }
  });
}
 

@Override
public void registerResetListener(SessionId sessionId,
                                  Consumer<ResetRequest> listener, Executor executor) {
  messagingService.registerHandler(String.format("reset-%d", sessionId.id()), (e, p) -> {
    listener.accept(serializer.decode(p));
  }, executor);
}
 

@Override
public void reset(Set<MemberId> members, ResetRequest request) {
  members.forEach(nodeId -> {
    LocalRaftServerProtocol server = server(nodeId);
    if (server != null) {
      server.reset(request.session(), encode(request));
    }
  });
}
 

@Override
public void registerResetListener(SessionId sessionId,
                                  Consumer<ResetRequest> listener, Executor executor) {
  messagingService.registerHandler(String.format("reset-%d", sessionId.id()), (e, p) -> {
    listener.accept(serializer.decode(p));
  }, executor);
}
 

@Override
public void reset(Set<MemberId> members, ResetRequest request) {
  members.forEach(nodeId -> {
    LocalRaftServerProtocol server = server(nodeId);
    if (server != null) {
      server.reset(request.session(), encode(request));
    }
  });
}
 

@Override
public void registerResetListener(SessionId sessionId, Consumer<ResetRequest> listener, Executor executor) {
  resetListeners.put(sessionId.id(), request -> executor.execute(() -> listener.accept(request)));
}
 

@Override
public void reset(Set<MemberId> members, ResetRequest request) {
  for (MemberId memberId : members) {
    sendAsync(memberId, String.format("reset-%d", request.session()), request);
  }
}
 

void reset(long sessionId, byte[] request) {
  Consumer<ResetRequest> listener = resetListeners.get(sessionId);
  if (listener != null) {
    listener.accept(decode(request));
  }
}
 

@Override
public void registerResetListener(SessionId sessionId, Consumer<ResetRequest> listener, Executor executor) {
  messagingService.registerHandler(String.format("reset-%d", sessionId.id()), (e, p) -> {
    listener.accept(serializer.decode(p));
  }, executor);
}
 

@Override
public void reset(Set<MemberId> members, ResetRequest request) {
  for (MemberId memberId : members) {
    sendAsync(memberId, String.format("reset-%d", request.session()), request);
  }
}
 

@Override
public void reset(Set<MemberId> members, ResetRequest request) {
  clusterCommunicator.multicast(context.resetSubject(request.session()), request, serializer::encode, members);
}
 

@Override
public void registerResetListener(SessionId sessionId, Consumer<ResetRequest> listener, Executor executor) {
  clusterCommunicator.subscribe(context.resetSubject(sessionId.id()), serializer::decode, listener, executor);
}
 

/**
 * Handles a publish request.
 *
 * @param request The publish request to handle.
 */
@SuppressWarnings("unchecked")
private void handlePublish(PublishRequest request) {
  log.trace("Received {}", request);

  // If the request is for another session ID, this may be a session that was previously opened
  // for this client.
  if (request.session() != state.getSessionId().id()) {
    log.trace("Inconsistent session ID: {}", request.session());
    return;
  }

  // Store eventIndex in a local variable to prevent multiple volatile reads.
  long eventIndex = state.getEventIndex();

  // If the request event index has already been processed, return.
  if (request.eventIndex() <= eventIndex) {
    log.trace("Duplicate event index {}", request.eventIndex());
    return;
  }

  // If the request's previous event index doesn't equal the previous received event index,
  // respond with an undefined error and the last index received. This will cause the cluster
  // to resend events starting at eventIndex + 1.
  if (request.previousIndex() != eventIndex) {
    log.trace("Inconsistent event index: {}", request.previousIndex());
    ResetRequest resetRequest = ResetRequest.builder()
        .withSession(state.getSessionId().id())
        .withIndex(eventIndex)
        .build();
    log.trace("Sending {}", resetRequest);
    protocol.reset(memberSelector.members(), resetRequest);
    return;
  }

  // Store the event index. This will be used to verify that events are received in sequential order.
  state.setEventIndex(request.eventIndex());

  sequencer.sequenceEvent(request, () -> {
    for (PrimitiveEvent event : request.events()) {
      Set<Consumer<PrimitiveEvent>> listeners = eventListeners.get(event.type());
      if (listeners != null) {
        for (Consumer<PrimitiveEvent> listener : listeners) {
          listener.accept(event);
        }
      }
    }
  });
}
 

@Override
public void registerResetListener(SessionId sessionId,
                                  Consumer<ResetRequest> listener, Executor executor) {
  resetListeners.put(sessionId.id(), request -> executor.execute(()
      -> listener.accept(request)));
}
 

void reset(long sessionId, byte[] request) {
  Consumer<ResetRequest> listener = resetListeners.get(sessionId);
  if (listener != null) {
    listener.accept(decode(request));
  }
}
 

@Override
public void reset(Set<MemberId> members, ResetRequest request) {
  for (MemberId memberId : members) {
    sendAsync(memberId, String.format("reset-%d", request.session()), request);
  }
}
 

@Override
public void registerResetListener(SessionId sessionId,
                                  Consumer<ResetRequest> listener, Executor executor) {
  resetListeners.put(sessionId.id(), request -> executor.execute(()
      -> listener.accept(request)));
}
 

void reset(long sessionId, byte[] request) {
  Consumer<ResetRequest> listener = resetListeners.get(sessionId);
  if (listener != null) {
    listener.accept(decode(request));
  }
}