大数据Paxos首页投稿（暂停使用，暂停投稿）

2. PhxPaxos分析之网络基础部件

2017-11-13  本文已影响153人  随安居士

目录
1. PhxPaxos源码分析之关于PhxPaxos
2. PhxPaxos分析之网络基础部件
3. PhxPaxos源码分析之Proposer、Acceptor
4. PhxPaxos源码分析之Learner
5. PhxPaxos源码分析之状态机
6. PhxPaxos源码分析之归档机制
7. PhxPaxos源码分析之整体架构

2.1 背景

Paxos 算法解决是一个分布式系统如何就某个值（决议）达成一致，因此网络通信是该算法可正常运行的基础。

在Paxos中，涉及网络通信的角色包括：

除算法本身角色外，PhxPaxos还设定了下述角色需要网络通信：

2.2 网络层架构

按协议划分，PhxPaxos支持TCP、UDP两种通信协议；按操作划分，支持网络数据读、写两种操作；按角色划分，分为客户端、服务器两种角色。在PhxPaxos中，服务器只负责读取操作，客户端只负责写入操作。因此，在最简场景下，我们需要4个封装类，分别如下：

而PhxPaxos中的实际实现要比这复杂的多，来看一组网络架构图：


PhxPaxos网络架构图

大致分为如下几部分：

2.3 TCP封装层

为了清楚了解作者意图，来看TCP封装层类图：


TCP封装层类图

各个类功能说明如下：

    void TcpIOThread :: Stop()
    {
        if (m_bIsStarted)
        {
            m_oTcpRead.Stop();
            m_oTcpWrite.Stop();
        }

        PLHead("TcpIOThread [END]");
    }

    int TcpIOThread :: Init(const std::string& sListenIp, const int iListenPort)
    {
        int ret = m_oTcpRead.Init(sListenIp, iListenPort);

        if (ret == 0)
        {
            return m_oTcpWrite.Init();
        }

        return ret;
    }

    void TcpIOThread :: Start()
    {
        m_oTcpWrite.start();
        m_oTcpRead.start();
        m_bIsStarted = true;
    }

    int TcpIOThread :: AddMessage(const std::string& sIP, const int iPort, const std::string& sMessage)
    {
        return m_oTcpWrite.AddMessage(sIP, iPort, sMessage);
    }

代码结构还算清晰，但是不是总觉得哪里不对？没关系，先顺着作者的思路看完。

2.4 整体网络抽象层

相比UDP、TCP封装层，整体网络抽象层是更高一级的概念。PhxPaxos中属于该层的网络抽象类如下：

    class NetWork
    {
    public:
        virtual void RunNetWork() = 0;
        virtual void StopNetWork() = 0;

        virtual int SendMessageTCP(const std::string& sIp, const int iPort, const std::string& sMessage) = 0;
        virtual int SendMessageUDP(const std::string& sIp, const int iPort, const std::string& sMessage) = 0;

        int OnReceiveMessage(const char* pcMessage, const int iMessageLen);
    };

    class DFNetWork : public NetWork
    {
    public:
        int Init(const std::string& sListenIp, const int iListenPort);

        //super interface
        ...
    private:
        UDPRecv m_oUDPRecv;
        UDPSend m_oUDPSend;
        TcpIOThread m_oTcpIOThread;
    };

    class MsgTransport
    {
    public:
        virtual int SendMessage(const nodeid_t iSendtoNodeID, const std::string& sBuffer,
                                const int iSendType = Message_SendType_UDP) = 0;
        virtual int BroadcastMessage(const std::string& sBuffer,
                                     const int iSendType = Message_SendType_UDP) = 0;
        virtual int BroadcastMessageFollower(const std::string& sBuffer,
                                             const int iSendType = Message_SendType_UDP) = 0;
        virtual int BroadcastMessageTempNode(const std::string& sBuffer,
                                             const int iSendType = Message_SendType_UDP) = 0;
    };

    class Communicate : public MsgTransport
    {
    public:
       //super interface 
       ...
    private:
        Config* m_poConfig;
        NetWork* m_poNetwork;

        nodeid_t m_iMyNodeID;
        size_t m_iUDPMaxSize;
    };

其实，这还没完，还有一个不属于“整体网络抽象层”的网络抽象，在base.h中。来看和网络相关的接口定义:

    class Base
    {
    public:
        int PackMsg(const PaxosMsg& oPaxosMsg, std::string& sBuffer);
        int PackCheckpointMsg(const CheckpointMsg& oCheckpointMsg, std::string& sBuffer);
        void PackBaseMsg(const std::string& sBodyBuffer, const int iCmd, std::string& sBuffer);
        static int UnPackBaseMsg(const std::string& sBuffer, Header& oHeader, size_t& iBodyStartPos, size_t& iBodyLen);

    protected:
        virtual int SendMessage(const nodeid_t iSendtoNodeID, const PaxosMsg& oPaxosMsg, const int iSendType = Message_SendType_UDP);
        virtual int BroadcastMessage(
            const PaxosMsg& oPaxosMsg,
            const int bRunSelfFirst = BroadcastMessage_Type_RunSelf_First,
            const int iSendType = Message_SendType_UDP);
        int BroadcastMessageToFollower(
            const PaxosMsg& oPaxosMsg,
            const int iSendType = Message_SendType_TCP);
        int BroadcastMessageToTempNode(
            const PaxosMsg& oPaxosMsg,
            const int iSendType = Message_SendType_UDP);
    protected:
        int SendMessage(const nodeid_t iSendtoNodeID, const CheckpointMsg& oCheckpointMsg,
                        const int iSendType = Message_SendType_TCP);

    protected:
        Config* m_poConfig;
        MsgTransport* m_poMsgTransport;
        Instance* m_poInstance;
    };

base是三个主要角色(Proposer、Accepor、Learner)的基类，这里网络相关操作主要包括打包和发送两种。和MsgTransport的发送接口相比有何区别呢？base中的发送函数负责打包、发送以及基于Instance对象的部分特殊处理。以其中的一个SendMessage为例：

    int Base :: SendMessage(const nodeid_t iSendtoNodeID, const PaxosMsg& oPaxosMsg, const int iSendType)
    {
        if (m_bIsTestMode)
        {
            return 0;
        }

        BP->GetInstanceBP()->SendMessage();
        //本节点立即处理
        if (iSendtoNodeID == m_poConfig->GetMyNodeID())
        {
            m_poInstance->OnReceivePaxosMsg(oPaxosMsg);
            return 0;
        }
        //打包
        string sBuffer;
        int ret = PackMsg(oPaxosMsg, sBuffer);
        if (ret != 0)
        {
            return ret;
        }
        //发送
        return m_poMsgTransport->SendMessage(iSendtoNodeID, sBuffer, iSendType);
    }

2.5 架构探讨

前面将PhxPaxos的网络层抽象类全部过了一遍，现在我们来窥视下作者的意图，并进一步探讨是否存在更合理的架构。

PhxPaxos的网络抽象层存在一个明显的分界点：NetWork抽象类。NetWork及其之下抽象是基于纯粹网络的，业务无关的；NetWork之上的是业务相关的。NetWork做为明显分界点到额另外一个原因是：允许PhxPaxos的使用者注册自己的NetWork实现类，以替换内置的DfNetWork。来看NetWork及其之下的抽象：
XXX

按文章中最初提到的观点，理想中的NetWork应该只包含四个类：TCPClient、TCPServer、UDPSender、UDPReceiver。当前UDP和预期一致，但TCP当前一共有9个类，比预想的多了7个。其中Socket和ServerSocket的抽象是合理的、粒度恰当的，Event概念引入及抽象略显奇怪。EventLoop的定位应该是一个Package Dispather(网络数据分发器)，它反向依赖了TcpAcceptor、TcpClient。而且在Phxpaxos场景下读写操作是完全隔离的。因此，Event、EventLoop的功能垂直拆分到TcpClient和TcpServer，薄抽象层TcpRead、TcpWrite、TcpIoThread移除或许更为合理。

针对NetWork层说几点：

class MessageHandler
{
    virtual  int OnReceiveMessage(const char* pcMessage, const int iMessageLen) = 0;
}

再来看MsgTransport、Communicate、base这三个类。因为NetWork只做纯网络的抽象，直接交由上层使用并不合适，因此基于业务抽象的MsgTransport接口确有必要。但这一层抽象并不彻底，进而又在base中做了二次封装。从设计上来看，有如下几个缺陷：

个人认为合理的做法应该是：

2.6 总结

Phxpaxos基于socket、poll、epoll构建自己的网络层，支持UDP、TCP两种通信方式。网络层一共启动了如下五个线程;

NetWork接口对外屏蔽了上述细节，并且允许用户替换为自己的网络部件。而Phxpaxos使用的是更上层的MsgTransport，其包含了和Phxpaxos业务相关的一些操作，如打包、本节点特殊处理等。

在完成了Communicate之后，我们有了一个有效的网络通信机制，下一步，让我们真正开始了解PhxPaxos的核心 --- Paxos算法实现。

【转载请注明】随安居士. 2. PhxPaxos分析之网络基础部件. 2017.11.13

上一篇 下一篇

猜你喜欢

热点阅读