简介

ratis服务中，每一个节点可能有三种身份，Leader,Candidate,Follower. Ratis在org.apache.ratis.server.impl.RoleInfo中实现身份管理。

看代码

Follower  state:

1. 初始化阶段：当节点启动时，它会首先成为 Follower 状态，并尝试加入集群中的其他节点。

2. 正常运行阶段：一旦节点成功加入集群并与 Leader 建立了连接，它将成为 Follower 状态。在这个状态下，节点将按照 Leader 的指导执行操作，并定期从 Leader 处接收心跳消息以维持其状态。

3. 等待一定的超时时间后，如果还没有收到Leader的心跳信息，则会将自己身份转换成Candidate，转换部分的代码如下：

synchronized (server) {
          if (outstandingOp.get() == 0
              && isRunning && server.getInfo().isFollower()
              && lastRpcTime.elapsedTime().compareTo(electionTimeout) >= 0
              && !lostMajorityHeartbeatsRecently()) {
            LOG.info("{}: change to CANDIDATE, lastRpcElapsedTime:{}, electionTimeout:{}",
                this, lastRpcTime.elapsedTime(), electionTimeout);
            server.getLeaderElectionMetrics().onLeaderElectionTimeout(); // Update timeout metric counters.
            // election timeout, should become a candidate
            server.changeToCandidate(false);
            break;
          }
}

等待的超时时间是随机的，每一组raftGroup中的节点，每一个follower的等待时间是一个配置中给定的时间范围内的随机值，这样可以有效保证leader有问题时，所有的follower不会同时切换状态到candidate再发起选举。

在RaftServerImpl中，通过方法changeToFollower让角色状态机进入到Follower的身份，该方法会关闭上一个身份的状态机（Leader的心跳守护线程和Candidate的选举线程），启动Follower状态机。对应的Follower状态代码实现在FollowerState中

private synchronized boolean changeToFollower(long newTerm, boolean force, Object reason) {
  final RaftPeerRole old = role.getCurrentRole();
  final boolean metadataUpdated = state.updateCurrentTerm(newTerm);

  if (old != RaftPeerRole.FOLLOWER || force) {
    setRole(RaftPeerRole.FOLLOWER, reason);
    if (old == RaftPeerRole.LEADER) {
      role.shutdownLeaderState(false);
    } else if (old == RaftPeerRole.CANDIDATE) {
      role.shutdownLeaderElection();
    } else if (old == RaftPeerRole.FOLLOWER) {
      role.shutdownFollowerState();
    }
    role.startFollowerState(this, reason);
  }
  return metadataUpdated;
}

Candidate state:

在Follower状态的节点，在指定超时时间内没有接收到Leader的rpc信息时，Follower状态的节点会发起状态变更请求，转换为Candidate状态，代码如下：

synchronized void changeToCandidate(boolean forceStartLeaderElection) {
    Preconditions.assertTrue(getInfo().isFollower());
    role.shutdownFollowerState();
    setRole(RaftPeerRole.CANDIDATE, "changeToCandidate");
    if (state.shouldNotifyExtendedNoLeader()) {
      stateMachine.followerEvent().notifyExtendedNoLeader(getRoleInfoProto());
    }
    // start election
    role.startLeaderElection(this, forceStartLeaderElection);
  }

通过调用startLeaderElection开始选举的流程，代码如下：

void startLeaderElection(RaftServerImpl server, boolean force) {
    if (pauseLeaderElection.get()) {
      return;
    }
    updateAndGet(leaderElection, new LeaderElection(server, force)).start();
  }

开启一个选举的守护线程LeaderElection，开始选举。选举的过程中做了两个优化

第一个是：预选举preVote，为保证在网络分区情况下，不会出现经常性的选举。在正式的选举前，先进行一轮PreVote选举，只有通过了PreVote选举，才会增加Term进行正式的选举。

第二个是：优先级选举，为防止出现多个Candidate瓜分选票。为所有的Raft Peer设置优先级，选举的时候，多个不同优先级的Candidate同时出现，高优先级的Candidate将会逼迫低优先级的Candidate进入Follower

选举过程如下：首先进行一轮PreVote，成功之后进行正式的Election，选举为Leader之后状态机会进入Leader身份。在每一轮的选举中，当前的Candidate必须要获得Majority的投票，并且获得所有Priority高于Candidate的Peer的投票，这样才算通过选举。

if (skipPreVote || askForVotes(Phase.PRE_VOTE, round)) {
   if (askForVotes(Phase.ELECTION, round)) {
      server.changeToLeader();
   }
}

其中，askForVote方法会向所有的Raft Group中的Peer发送对应的Request Vote RPC，并且收集最终选举结果。

private ResultAndTerm submitRequestAndWaitResult(Phase phase, RaftConfigurationImpl conf, long electionTerm)
      throws InterruptedException {
    if (!conf.containsInConf(server.getId())) {
      return new ResultAndTerm(Result.NOT_IN_CONF, electionTerm);
    }
    final ResultAndTerm r;
    final Collection<RaftPeer> others = conf.getOtherPeers(server.getId());
    if (others.isEmpty()) {
      r = new ResultAndTerm(Result.PASSED, electionTerm);
    } else {
      final TermIndex lastEntry = server.getState().getLastEntry();
      final Executor voteExecutor = new Executor(this, others.size());
      try {
        // 发送rpc请求
        final int submitted = submitRequests(phase, electionTerm, lastEntry, others, voteExecutor);
        r = waitForResults(phase, electionTerm, submitted, conf, voteExecutor);
      } finally {
        voteExecutor.shutdown();
      }
    }

    return r;
  }

其中，SubmitRequests负责发送RPC请求，通过一个固定线程池完成网络任务。waitForResults会在下次ElectionTimeOut之前等待RPC的回复，并根据是否选举成功（Majority+Priority)来返回本次选举结果。如果选举成功，那么就会调用RaftServerImpl的方法changeToLeader进入Leader身份。

Leader state:

在选举获得大部分的投票之后，candidate可以成为Leader的状态，调用changeToLeader，切换成为Leader的状态，代码如下：

synchronized void changeToLeader() {
    Preconditions.assertTrue(getInfo().isCandidate());
    // 关闭选举线程
    role.shutdownLeaderElection();
    setRole(RaftPeerRole.LEADER, "changeToLeader");
    state.becomeLeader();

    // start sending AppendEntries RPC to followers
    final LogEntryProto e = role.startLeaderState(this);
    getState().setRaftConf(e);
  }

在成为Leader之后会开启Leader的工作线程，其中包含负责RaftLog功能，向Follower通信，同步Log保证主备一致性。在成为新的Leader之后，会首先commit一条no-op，保证之前所有的日志被复制到Raft Peers，同时也能精准地获取到Term和Index的信息，返回给ServerStateMachine。代码如下：

LogEntryProto start() {
    // In the beginning of the new term, replicate a conf entry in order
    // to finally commit entries in the previous term.
    // Also this message can help identify the last committed index and the conf.
    final LogEntryProto placeHolder = LogProtoUtils.toLogEntryProto(
        server.getRaftConf(), server.getState().getCurrentTerm(), raftLog.getNextIndex());
    CodeInjectionForTesting.execute(APPEND_PLACEHOLDER,
        server.getId().toString(), null);
    raftLog.append(Collections.singletonList(placeHolder));
    processor.start();
    senders.forEach(LogAppender::start);
    return placeHolder;
  }

对于每一个Follower都启动一个LogAppender线程，负责向Follower发送日志，并且负责snapshot相关的工作。