예제 #1
0
  private boolean updateFollowerLogInformation(
      FollowerLogInformation followerLogInformation, AppendEntriesReply appendEntriesReply) {
    boolean updated = followerLogInformation.setMatchIndex(appendEntriesReply.getLogLastIndex());
    updated =
        followerLogInformation.setNextIndex(appendEntriesReply.getLogLastIndex() + 1) || updated;

    if (updated && LOG.isDebugEnabled()) {
      LOG.debug(
          "{}: handleAppendEntriesReply - FollowerLogInformation for {} updated: matchIndex: {}, nextIndex: {}",
          logName(),
          followerLogInformation.getId(),
          followerLogInformation.getMatchIndex(),
          followerLogInformation.getNextIndex());
    }
    return updated;
  }
예제 #2
0
  @Override
  protected RaftActorBehavior handleAppendEntriesReply(
      ActorRef sender, AppendEntriesReply appendEntriesReply) {

    if (LOG.isTraceEnabled()) {
      LOG.trace("{}: handleAppendEntriesReply: {}", logName(), appendEntriesReply);
    }

    // Update the FollowerLogInformation
    String followerId = appendEntriesReply.getFollowerId();
    FollowerLogInformation followerLogInformation = followerToLog.get(followerId);

    if (followerLogInformation == null) {
      LOG.error("{}: handleAppendEntriesReply - unknown follower {}", logName(), followerId);
      return this;
    }

    if (followerLogInformation.timeSinceLastActivity()
        > context.getConfigParams().getElectionTimeOutInterval().toMillis()) {
      LOG.warn(
          "{} : handleAppendEntriesReply delayed beyond election timeout, "
              + "appendEntriesReply : {}, timeSinceLastActivity : {}, lastApplied : {}, commitIndex : {}",
          logName(),
          appendEntriesReply,
          followerLogInformation.timeSinceLastActivity(),
          context.getLastApplied(),
          context.getCommitIndex());
    }

    followerLogInformation.markFollowerActive();
    followerLogInformation.setPayloadVersion(appendEntriesReply.getPayloadVersion());

    boolean updated = false;
    if (appendEntriesReply.isSuccess()) {
      updated = updateFollowerLogInformation(followerLogInformation, appendEntriesReply);
    } else {
      LOG.debug(
          "{}: handleAppendEntriesReply: received unsuccessful reply: {}",
          logName(),
          appendEntriesReply);

      long followerLastLogIndex = appendEntriesReply.getLogLastIndex();
      ReplicatedLogEntry followersLastLogEntry =
          context.getReplicatedLog().get(followerLastLogIndex);
      if (appendEntriesReply.isForceInstallSnapshot()) {
        // Reset the followers match and next index. This is to signal that this follower has
        // nothing
        // in common with this Leader and so would require a snapshot to be installed
        followerLogInformation.setMatchIndex(-1);
        followerLogInformation.setNextIndex(-1);

        // Force initiate a snapshot capture
        initiateCaptureSnapshot(followerId);
      } else if (followerLastLogIndex < 0
          || (followersLastLogEntry != null
              && followersLastLogEntry.getTerm() == appendEntriesReply.getLogLastTerm())) {
        // The follower's log is empty or the last entry is present in the leader's journal
        // and the terms match so the follower is just behind the leader's journal from
        // the last snapshot, if any. We'll catch up the follower quickly by starting at the
        // follower's last log index.

        updated = updateFollowerLogInformation(followerLogInformation, appendEntriesReply);
      } else {
        // TODO: When we find that the follower is out of sync with the
        // Leader we simply decrement that followers next index by 1.
        // Would it be possible to do better than this? The RAFT spec
        // does not explicitly deal with it but may be something for us to
        // think about.

        followerLogInformation.decrNextIndex();
      }
    }

    // Now figure out if this reply warrants a change in the commitIndex
    // If there exists an N such that N > commitIndex, a majority
    // of matchIndex[i] ≥ N, and log[N].term == currentTerm:
    // set commitIndex = N (§5.3, §5.4).
    for (long N = context.getCommitIndex() + 1; ; N++) {
      int replicatedCount = 1;

      for (FollowerLogInformation info : followerToLog.values()) {
        if (info.getMatchIndex() >= N) {
          replicatedCount++;
        }
      }

      if (replicatedCount >= minReplicationCount) {
        ReplicatedLogEntry replicatedLogEntry = context.getReplicatedLog().get(N);
        if (replicatedLogEntry != null && replicatedLogEntry.getTerm() == currentTerm()) {
          context.setCommitIndex(N);
        } else {
          break;
        }
      } else {
        break;
      }
    }

    // Apply the change to the state machine
    if (context.getCommitIndex() > context.getLastApplied()) {
      if (LOG.isDebugEnabled()) {
        LOG.debug(
            "{}: handleAppendEntriesReply from {}: applying to log - commitIndex: {}, lastAppliedIndex: {}",
            logName(),
            followerId,
            context.getCommitIndex(),
            context.getLastApplied());
      }

      applyLogToStateMachine(context.getCommitIndex());
    }

    if (!context.getSnapshotManager().isCapturing()) {
      purgeInMemoryLog();
    }

    // Send the next log entry immediately, if possible, no need to wait for heartbeat to trigger
    // that event
    sendUpdatesToFollower(followerId, followerLogInformation, false, !updated);
    return this;
  }