zookeeper Zab协议—Follower和Leader状态同步-细节分析二

最新推荐文章于 2024-07-15 13:09:57 发布

L25809

最新推荐文章于 2024-07-15 13:09:57 发布

阅读量1.1k

点赞数

文章标签： zookeeper

本文链接：https://blog.csdn.net/L25809/article/details/120922419

版权

本文深入分析了Zookeeper的ZAB协议中Follower和Leader的状态同步过程，详细阐述了从LearnerHandler.run()方法开始，包括创建新Epoch、消息提交、同步数据等关键步骤，直至FollowerZooKeeperServer.commit()向Leader回复的完整流程。

摘要由CSDN通过智能技术生成

2021SC@SDUSC

一、Follower和Leader状态同步-代码细节分析

7.LearnerHandler.run()方法读数据，读follower传过来的packet信息，创建新的Epoch，发送给follower，并等待应答后，进行消息同步

8.follower接收到新的Epoch，并回复leader

Learner.registerWithLeader()

9.消息同步

（1）提交提案

（2）LearnerHandleader.queueCommittedProposals()将Leader.COMMIT发给follower

（3）follower接收Leader.COMMIT

（4）FollowerZooKeeperServer.commit() 向Leader回复

（5）发送同步数据

二、总结

2021SC@SDUSC

一、Follower和Leader状态同步-代码细节分析

7.LearnerHandler.run()方法读数据，读follower传过来的packet信息，创建新的Epoch，发送给follower，并等待应答后，进行消息同步

    public void run() {
        try {
            leader.addLearnerHandler(this);
            tickOfNextAckDeadline = leader.self.tick.get()
                    + leader.self.initLimit + leader.self.syncLimit;

            ia = BinaryInputArchive.getArchive(bufferedInput);
            bufferedOutput = new BufferedOutputStream(sock.getOutputStream());
            oa = BinaryOutputArchive.getArchive(bufferedOutput);

            QuorumPacket qp = new QuorumPacket();
            
//读取follower传过来的packet信息
            ia.readRecord(qp, "packet");


            if(qp.getType() != Leader.FOLLOWERINFO && qp.getType() != 
                Leader.OBSERVERINFO){
                LOG.error("First packet " + qp.toString()
                        + " is not FOLLOWERINFO or OBSERVERINFO!");
                return;
            }

            byte learnerInfoData[] = qp.getData();
            if (learnerInfoData != null) {
                ByteBuffer bbsid = ByteBuffer.wrap(learnerInfoData);
                if (learnerInfoData.length >= 8) {
                    this.sid = bbsid.getLong();
                }
                if (learnerInfoData.length >= 12) {
                    this.version = bbsid.getInt(); // protocolVersion
                }
                if (learnerInfoData.length >= 20) {
                    long configVersion = bbsid.getLong();
                    if (configVersion > leader.self.getQuorumVerifier().getVersion()) {
                        throw new IOException("Follower is ahead of the leader (has a 
                later activated configuration)");
                    }
                }
            } else {
                this.sid = leader.followerCounter.getAndDecrement();
            }

            if (leader.self.getView().containsKey(this.sid)) {
                LOG.info("Follower sid: " + this.sid + " : info : "
                        + leader.self.getView().get(this.sid).toString());
            } else {
                LOG.info("Follower sid: " + this.sid + " not in the current config " +                     
                Long.toHexString(leader.self.getQuorumVerifier().getVersion()));
            }
                        
            if (qp.getType() == Leader.OBSERVERINFO) {
                  learnerType = LearnerType.OBSERVER;
            }

            long lastAcceptedEpoch = ZxidUtils.getEpochFromZxid(qp.getZxid());

            long peerLastZxid;
            StateSummary ss = null;
            long zxid = qp.getZxid();

//创建新的Epoch
            long newEpoch = leader.getEpochToPropose(this.getSid(), lastAcceptedEpoch);
            long newLeaderZxid = ZxidUtils.makeZxid(newEpoch, 0);

           if (this.getVersion() < 0x10000) {
                // we are going to have to extrapolate the epoch information
                long epoch = ZxidUtils.getEpochFromZxid(zxid);
                ss = new StateSummary(epoch, zxid);
                // fake the message
                leader.waitForEpochAck(this.getSid(), ss);
            } else {
                byte ver[] = new byte[4];
                ByteBuffer.wrap(ver).putInt(0x10000);
                

//将新的Epoch发送给follower
                QuorumPacket newEpochPacket = new QuorumPacket(Leader.LEADERINFO, newLeaderZxid, ver, null);
                oa.writeRecord(newEpochPacket, "packet");
                bufferedOutput.flush();
                QuorumPacket ackEpochPacket = new QuorumPacket();
                ia.readRecord(ackEpochPacket, "packet");
                if (ackEpochPacket.getType() != Leader.ACKEPOCH) {
                    LOG.error(ackEpochPacket.toString()
                            + " is not ACKEPOCH");
                    return;
				}
                ByteBuffer bbepoch = ByteBuffer.wrap(ackEpochPacket.getData());
                ss = new StateSummary(bbepoch.getInt(), ackEpochPacket.getZxid());
//等待应答
                le