分布式一致性Raft算法

---

在之前的博客中，zookeeper原理及apache zookeeper源码阅读，我在里面介绍了关于zk选主算法：分布式一致性算法Paxos，对于Paxos算法的理解，一直都是公认的生涩难懂，在这个博客中，我们会学习另一个分布式一致性算法，那就是raft

1 raft算法详解

首先，raft算法是一种基于日志复制的一致性算法，并且raft的结果等价于paxos算法，同时它是一种更加简单，更易理解的分布式一致性算法（来自于raft论文）

如果你准备去学习raft算法的话，强烈的建议你阅读raft的论文
In Search of an Understandable Consensus Algorithm

如果你不是看的懂英文，github里面也有对应的中文翻译的版本，
https://github.com/brandonwang001/raft_translation

同时github中也有人对于raft的原理使用动图展示的形式进行讲解【这个强烈建议你看一遍】：
Raft Understandable Distributed Consensus

个人总结：

对于Raft算法，所有的节点都会有这三个状态：Follower, Candidate,Leader

选举过程（Leader Election）：

并且，初始状态下，所有的节点都是Follower状态，当followers状态的节点在一定（election timeout）时间内没有收到leader的心跳信息后，就会处于Candidate状态，

处于Candidate状态的节点，这个时候会请求其他的节点，进行自我Leader的选举，如果收到多数的选举票数的话，那么该节点就会处于Leader节点


日志复制（Log Replication）：
此时，选举出了Leader之后，所有的数据改变都是在Leader节点上，
每一个改变，都会建立在leader 节点上的日志记录上（暂存），Leader节点会向Follower节点发起数据复制的请求，当被Leader节点记录的日志的数据被大多数（majority）Follower节点所复制记录（暂存到log）之后，那么，认为本次服务数据有效，当前改变的数值会被记录到Leader Node 中去

然后Leader节点会向Follower节点发起通知，同时Follower节点会将复制的数据从log中记录到Follower Node中，本次数据复制完成。

到这里，我们都是看到了对于Raft正常的情况下的顺利操作，但是实际的情况往往复杂的多，

对于Follower在election timeout内没有收到来自leader的心跳之后进入Candidate状态，该情况可能来自于分布式系统中还没有选举Leader，或者是此时被选举出来的Leader已经挂掉，或者是当前的Follower节点和Leader节点出现了网络故障，无法连接。

• 1，当Follower在election timeout内没有收到Leader的心跳之后，首先会变成Candidate状态，然后本地Node会记录一个新的Term(选举周期 )
• 2，当前处于Candidate状态的Node会投自己一票
• 3，并行给其他节点发送 RequestVote RPCs
• 4，等待其他，
• 如果等待的节点还没有在这次Term进行投票的话，那么就会投给当前发起RequestVote RPCs的Candidate节点
• 成为Leader的节点会间隔一定时间headbeat time 发送心跳数据

在选举的过程中，处于Follower状态的节点在选举的时候必须满足这几点：

• 在任一Term内，每一个Follower节点只能投一次票
• 同时，发起投票的Candidate状态的节点知道的信息不能比Follower少

Raft算法是如何保证同一个时刻含有两个Candidate，并且同时平分选票的过程

通过每一个节点设置随机的election time加上集群中设置奇数个节点

Raft节点当Leader节点收到了Client发起的请求，写入到Log Entry之后，Crash之后，系统如何进行处理 ？

这种情况是属于分布式一致性的集群错误，Raft通过缩短election time（随机范围：50ms and 300ms）来快速进行系统Leader的确认，当处于Leader的节点接收请求之后挂掉，此时分布式系统会再次确认新得Leader（此时其他可用的Node会在一个新的Term中），此时如果原始的Leader启动，会接收到新得Leader的心跳，会记录到最新的Term和Log Entry信息

2 raft算法实例

对于raft算法，各个平台的语言都对其进行了大量的实现，raft.github.io 上对于raft的算法实现starts也进行了统计

2.1 nacos中的raft算法实现

nacos中的Raft算法的实现，是基于其搭建分布式集群环境下，提供的分布式一致性的数据服务。

服务通过Rest接口发起注册到Nacos Service时，内部调用InstanceController#register 进行注册逻辑操作，最终通过consistencyService.put(key, instances); 进行注册服务的持久化操作

consistencyService 通过注册的Instance的ephemeral 成员变量来决定使用
PersistentConsistencyService（Raft）和EphemeralConsistencyService（Distro）

Nacos的分布式一致性的实现都是基于ConsistencyService接口进行实现，该接口提供了基础的
put，remove，get，listen，unlisten，isAvailable
方法

/**
     * Put a data related to a key to Nacos cluster
     *
     * @param key   key of data, this key should be globally unique
     * @param value value of data
     * @throws NacosException
     * @see
     */
    void put(String key, Record value) throws NacosException;

    /**
     * Remove a data from Nacos cluster
     *
     * @param key key of data
     * @throws NacosException
     */
    void remove(String key) throws NacosException;

    /**
     * Get a data from Nacos cluster
     *
     * @param key key of data
     * @return data related to the key
     * @throws NacosException
     */
    Datum get(String key) throws NacosException;

    /**
     * Listen for changes of a data
     *
     * @param key      key of data
     * @param listener callback of data change
     * @throws NacosException
     */
    void listen(String key, RecordListener listener) throws NacosException;

    /**
     * Cancel listening of a data
     *
     * @param key      key of data
     * @param listener callback of data change
     * @throws NacosException
     */
    void unlisten(String key, RecordListener listener) throws NacosException;

    /**
     * Tell the status of this consistency service
     *
     * @return true if available
     */
    boolean isAvailable();

Nacos中Raft实现的核心包：

同时提供了一个RaftController（com.alibaba.nacos.naming.controllers.RaftController），RestAPI接口实现，作为Leader节点的数据交换和心跳检测

Nacos对于Raft实现的几个核心包：

• RaftCore: 实现Raft功能的核心算法，核心实现
• RaftPeer: Raft节点的对象，其成员变量描述了单个节点的信息
• RaftPeerSet：当前系统持有的系统所有的RaftPeer
• RaftStore :持久化到磁盘文件的工具

其中Raft内部的几个核心成员变量：

/**
     * 记录监听
     */
    private volatile Map<String, List<RecordListener>> listeners = new ConcurrentHashMap<>();

    /**
     * 当前持久化的数据
     */
    private volatile ConcurrentMap<String, Datum> datums = new ConcurrentHashMap<>();

    /**
     * 当前节点持有的同伴节点的信息
     */
    @Autowired
    private RaftPeerSet peers;

    /**
     * naming中关键的配置属性信息
     */
    @Autowired
    private SwitchDomain switchDomain;

    /**
     * 公共的配置信息
     */
    @Autowired
    private GlobalConfig globalConfig;

    /**
     * 用于转发请求给Leader
     */
    @Autowired
    private RaftProxy raftProxy;

    /**
     * 持久化节点信息到磁盘的累
     */
    @Autowired
    private RaftStore raftStore;

进入到RaftCore的init（）方法，该方法由@PostConstruct注释，其内部会注册MasterElection（选主），HeartBeat（心跳检测）两个任务，

选主：

public void run() {
            try {

                if (!peers.isReady()) {
                    return;
                }

                RaftPeer local = peers.local();
                local.leaderDueMs -= GlobalExecutor.TICK_PERIOD_MS;

                if (local.leaderDueMs > 0) {
                    return;
                }

                // reset timeout
                local.resetLeaderDue();
                local.resetHeartbeatDue();

                sendVote();
            } catch (Exception e) {
                Loggers.RAFT.warn("[RAFT] error while master election {}", e);
            }

        }

选择任务交由线程池执行，每次执行首先需要判断当前节点持有的集群所有节点peers处于ready状态，

该ready状态交由RaftPeerSet中的onChangeServerList 触发更新，我们在看RaftPeerSet类的时候，会发现其类依赖于serverListManager类

@Component
@DependsOn("serverListManager")
public class RaftPeerSet implements ServerChangeListener, ApplicationContextAware {
	....
}

ServerListManager类中启动后，首先执行init() 方法

	@PostConstruct
    public void init() {
        GlobalExecutor.registerServerListUpdater(new ServerListUpdater());
        GlobalExecutor.registerServerStatusReporter(new ServerStatusReporter(), 5000);
    }

init方法内注册了两个定时任务ServerListUpdater和ServerStatusReporter，
其中ServerListUpdater任务会首先检测当前节点中的cluster.conf配置的集群节点服务地址，

		@Override
        public void run() {
            try {
                List<Server> refreshedServers = refreshServerList();
                List<Server> oldServers = servers;

                if (CollectionUtils.isEmpty(refreshedServers)) {
                    Loggers.RAFT.warn("refresh server list failed, ignore it.");
                    return;
                }

                boolean changed = false;

                List<Server> newServers = (List<Server>) CollectionUtils.subtract(refreshedServers, oldServers);
                if (CollectionUtils.isNotEmpty(newServers)) {
                    servers.addAll(newServers);
                    changed = true;
                    Loggers.RAFT.info("server list is updated, new: {} servers: {}", newServers.size(), newServers);
                }

                List<Server> deadServers = (List<Server>) CollectionUtils.subtract(oldServers, refreshedServers);
                if (CollectionUtils.isNotEmpty(deadServers)) {
                    servers.removeAll(deadServers);
                    changed = true;
                    Loggers.RAFT.info("server list is updated, dead: {}, servers: {}", deadServers.size(), deadServers);
                }

                if (changed) {
                    notifyListeners();
                }

            } catch (Exception e) {
                Loggers.RAFT.info("error while updating server list.", e);
            }
        }

通过refreshServerList() 方法获取，当触发了当前配置服务节点和系统servers不一致时，触发notifyListeners(); 方法，最终会触发RaftPeerSet的onChangeServerList 方法

@Override
    public void onChangeServerList(List<Server> latestMembers) {

        Map<String, RaftPeer> tmpPeers = new HashMap<>(8);
        for (Server member : latestMembers) {

            if (peers.containsKey(member.getKey())) {
                tmpPeers.put(member.getKey(), peers.get(member.getKey()));
                continue;
            }

            RaftPeer raftPeer = new RaftPeer();
            raftPeer.ip = member.getKey();

            // first time meet the local server:
            if (NetUtils.localServer().equals(member.getKey())) {
                raftPeer.term.set(localTerm.get());
            }

            tmpPeers.put(member.getKey(), raftPeer);
        }

        // replace raft peer set:
        peers = tmpPeers;

        if (RunningConfig.getServerPort() > 0) {
            ready = true;
        }

        Loggers.RAFT.info("raft peers changed: " + latestMembers);
    }

改方法通过RunningConfig.getServerPort() ，通过判断当前服务启动节点port是否大于0 ，最终修改了当前ready的状态，

而serverPost修改的触发又是基于onApplicationEvent
（onApplicationEvent的触发是系统启动之后，晚于PostConstruct）
因此，我们可以确定，系统在进行选主时，当前节点服务已经完全启动完毕。

回到RaftCore#MasterElection的init方法
判断peers.isReady() 之后，每次执行会对当前RaftPeer的节点的leaderDueMs 进行随机递减（减少Raft平票概率），当递减至值小于0时，说明当前follower节点未接收到心跳，则自动变为Candidate，参与选票

每一个RaftPeer的leaderDueMs 的更改，我们可以从源码看到

• 1，发起投票之前
• 2，接收投票 receivedVote（RaftPeer remote）

public void sendVote() {

            RaftPeer local = peers.get(NetUtils.localServer());
            Loggers.RAFT.info("leader timeout, start voting,leader: {}, term: {}",
                JSON.toJSONString(getLeader()), local.term);

            peers.reset();

            local.term.incrementAndGet();
            local.voteFor = local.ip;
            local.state = RaftPeer.State.CANDIDATE;

            Map<String, String> params = new HashMap<>(1);
            params.put("vote", JSON.toJSONString(local));
            for (final String server : peers.allServersWithoutMySelf()) {
                final String url = buildURL(server, API_VOTE);
                try {
                    HttpClient.asyncHttpPost(url, null, params, new AsyncCompletionHandler<Integer>() {
                        @Override
                        public Integer onCompleted(Response response) throws Exception {
                            if (response.getStatusCode() != HttpURLConnection.HTTP_OK) {
                                Loggers.RAFT.error("NACOS-RAFT vote failed: {}, url: {}", response.getResponseBody(), url);
                                return 1;
                            }

                            RaftPeer peer = JSON.parseObject(response.getResponseBody(), RaftPeer.class);

                            Loggers.RAFT.info("received approve from peer: {}", JSON.toJSONString(peer));

                            peers.decideLeader(peer);

                            return 0;
                        }
                    });
                } catch (Exception e) {
                    Loggers.RAFT.warn("error while sending vote to server: {}", server);
                }
            }
        }
    }

处于Candidiate状态的节点，发起投票，首先会自增自身的Term，发起新的一轮投票，然后通过HttpClient 的方式，向当前节点保留的 Peers发起投票请求接口，当投票接口返回200时，处理对应的返回投票实体信息，进行判断投票：

peers.decideLeader(peer);

public RaftPeer decideLeader(RaftPeer candidate) {
        peers.put(candidate.ip, candidate);

        SortedBag ips = new TreeBag();
        int maxApproveCount = 0;
        String maxApprovePeer = null;
        for (RaftPeer peer : peers.values()) {
            if (StringUtils.isEmpty(peer.voteFor)) {
                continue;
            }

            ips.add(peer.voteFor);
            if (ips.getCount(peer.voteFor) > maxApproveCount) {
                maxApproveCount = ips.getCount(peer.voteFor);
                maxApprovePeer = peer.voteFor;
            }
        }

        if (maxApproveCount >= majorityCount()) {
            RaftPeer peer = peers.get(maxApprovePeer);
            peer.state = RaftPeer.State.LEADER;

            if (!Objects.equals(leader, peer)) {
                leader = peer;
                applicationContext.publishEvent(new LeaderElectFinishedEvent(this, leader));
                Loggers.RAFT.info("{} has become the LEADER", leader.ip);
            }
        }

        return leader;
    }

该方法首先会追加对应的投票节点信息，并判断当前节点持有的RaftPeerSet 的节点个数是否大于majorityCount（）

public int majorityCount() {
        return peers.size() / 2 + 1;
    }

即认为本地投票当前节点Candidate获取多数投票，成为leader

对于数据支付，Nacos是通过HeartBeat 实现，进入到HeartBeat的run方法

public void run() {
            try {

                if (!peers.isReady()) {
                    return;
                }

                RaftPeer local = peers.local();
                local.heartbeatDueMs -= GlobalExecutor.TICK_PERIOD_MS;
                if (local.heartbeatDueMs > 0) {
                    return;
                }

                local.resetHeartbeatDue();

                sendBeat();
            } catch (Exception e) {
                Loggers.RAFT.warn("[RAFT] error while sending beat {}", e);
            }

        }

同样，针对于Leader发起的心跳检测，同样需要检验当前系统所持有的同类RaftPeerSet处于ready状态，然后持有一个heartbeatDueMs，每次调度都会自减，当heartbeatDueMs自减0以下之后，需要发起心跳，同时会重置当前的heartbeatDueMs 参数

public void sendBeat() throws IOException, InterruptedException {
            RaftPeer local = peers.local();
            if (local.state != RaftPeer.State.LEADER && !STANDALONE_MODE) {
                return;
            }

            if (Loggers.RAFT.isDebugEnabled()) {
                Loggers.RAFT.debug("[RAFT] send beat with {} keys.", datums.size());
            }

            local.resetLeaderDue();

            // build data
            JSONObject packet = new JSONObject();
            packet.put("peer", local);

            JSONArray array = new JSONArray();

            if (switchDomain.isSendBeatOnly()) {
                Loggers.RAFT.info("[SEND-BEAT-ONLY] {}", String.valueOf(switchDomain.isSendBeatOnly()));
            }

            if (!switchDomain.isSendBeatOnly()) {
                for (Datum datum : datums.values()) {

                    JSONObject element = new JSONObject();

                    if (KeyBuilder.matchServiceMetaKey(datum.key)) {
                        element.put("key", KeyBuilder.briefServiceMetaKey(datum.key));
                    } else if (KeyBuilder.matchInstanceListKey(datum.key)) {
                        element.put("key", KeyBuilder.briefInstanceListkey(datum.key));
                    }
                    element.put("timestamp", datum.timestamp);

                    array.add(element);
                }
            }

            packet.put("datums", array);
            // broadcast
            Map<String, String> params = new HashMap<String, String>(1);
            params.put("beat", JSON.toJSONString(packet));

            String content = JSON.toJSONString(params);

            ByteArrayOutputStream out = new ByteArrayOutputStream();
            GZIPOutputStream gzip = new GZIPOutputStream(out);
            gzip.write(content.getBytes(StandardCharsets.UTF_8));
            gzip.close();

            byte[] compressedBytes = out.toByteArray();
            String compressedContent = new String(compressedBytes, StandardCharsets.UTF_8);

            if (Loggers.RAFT.isDebugEnabled()) {
                Loggers.RAFT.debug("raw beat data size: {}, size of compressed data: {}",
                    content.length(), compressedContent.length());
            }

            for (final String server : peers.allServersWithoutMySelf()) {
                try {
                    final String url = buildURL(server, API_BEAT);
                    if (Loggers.RAFT.isDebugEnabled()) {
                        Loggers.RAFT.debug("send beat to server " + server);
                    }
                    HttpClient.asyncHttpPostLarge(url, null, compressedBytes, new AsyncCompletionHandler<Integer>() {
                        @Override
                        public Integer onCompleted(Response response) throws Exception {
                            if (response.getStatusCode() != HttpURLConnection.HTTP_OK) {
                                Loggers.RAFT.error("NACOS-RAFT beat failed: {}, peer: {}",
                                    response.getResponseBody(), server);
                                MetricsMonitor.getLeaderSendBeatFailedException().increment();
                                return 1;
                            }

                            peers.update(JSON.parseObject(response.getResponseBody(), RaftPeer.class));
                            if (Loggers.RAFT.isDebugEnabled()) {
                                Loggers.RAFT.debug("receive beat response from: {}", url);
                            }
                            return 0;
                        }

                        @Override
                        public void onThrowable(Throwable t) {
                            Loggers.RAFT.error("NACOS-RAFT error while sending heart-beat to peer: {} {}", server, t);
                            MetricsMonitor.getLeaderSendBeatFailedException().increment();
                        }
                    });
                } catch (Exception e) {
                    Loggers.RAFT.error("error while sending heart-beat to peer: {} {}", server, e);
                    MetricsMonitor.getLeaderSendBeatFailedException().increment();
                }
            }

        }
    }

心跳检测的逻辑也很简单，大致是：

判断当前系统处于集群状态，并且当前节点为Leader时，才发起心跳检测
重置当前系统的选主间隔时间leaderDueMs
附带心跳数据（根据switchDomain.isSendBeatOnly()）判断，
通过HttpClient发起心跳数据，

同样，对于收到投票请求的节点而言，其内部的处理逻辑也不复杂：

public RaftPeer receivedVote(RaftPeer remote) {
        if (!peers.contains(remote)) {
            throw new IllegalStateException("can not find peer: " + remote.ip);
        }

        RaftPeer local = peers.get(NetUtils.localServer());
        if (remote.term.get() <= local.term.get()) {
            String msg = "received illegitimate vote" +
                ", voter-term:" + remote.term + ", votee-term:" + local.term;

            Loggers.RAFT.info(msg);
            if (StringUtils.isEmpty(local.voteFor)) {
                local.voteFor = local.ip;
            }

            return local;
        }

        local.resetLeaderDue();

        local.state = RaftPeer.State.FOLLOWER;
        local.voteFor = remote.ip;
        local.term.set(remote.term.get());

        Loggers.RAFT.info("vote {} as leader, term: {}", remote.ip, remote.term);

        return local;
    }

1，获取当前节点RaftPeer
2，如果当前节点的Term大于等于发起投票的节点Term，（此时是非法投票数据，可能的原因是原始的Leader宕机，并且过后一段时间开机，发起了投票）
3，重置leaderDueMs选举时间间隔
4，设置当前节点为Follower，并且设置投票voteFor和term

对于节点接收心跳信息：

public RaftPeer makeLeader(RaftPeer candidate) {
        // 如果当前节点持有的leader和当前的发起的节点不相同，需要当前节点去同步最新数据
        if (!Objects.equals(leader, candidate)) {
            leader = candidate;
            applicationContext.publishEvent(new MakeLeaderEvent(this, leader));
            Loggers.RAFT.info("{} has become the LEADER, local: {}, leader: {}",
                leader.ip, JSON.toJSONString(local()), JSON.toJSONString(leader));
        }

        // 处理当前持有节点的同伴节点信息
        for (final RaftPeer peer : peers.values()) {
            Map<String, String> params = new HashMap<>(1);
            // 处理当前节点持有的属于leader的节点信息，此时需要及时通知当前节点PeerSet对应的leader，进行数据同步
            if (!Objects.equals(peer, candidate) && peer.state == RaftPeer.State.LEADER) {
                try {
                    String url = RaftCore.buildURL(peer.ip, RaftCore.API_GET_PEER);
                    HttpClient.asyncHttpGet(url, null, params, new AsyncCompletionHandler<Integer>() {
                        @Override
                        public Integer onCompleted(Response response) throws Exception {
                            if (response.getStatusCode() != HttpURLConnection.HTTP_OK) {
                                Loggers.RAFT.error("[NACOS-RAFT] get peer failed: {}, peer: {}",
                                    response.getResponseBody(), peer.ip);
                                peer.state = RaftPeer.State.FOLLOWER;
                                return 1;
                            }

                            update(JSON.parseObject(response.getResponseBody(), RaftPeer.class));

                            return 0;
                        }
                    });
                } catch (Exception e) {
                    peer.state = RaftPeer.State.FOLLOWER;
                    Loggers.RAFT.error("[NACOS-RAFT] error while getting peer from peer: {}", peer.ip);
                }
            }
        }

        return update(candidate);
    }

2.2 hazelcast

待研究。。。