源码读 NetworkInterface

最新推荐文章于 2024-01-20 00:05:46 发布

九嶷山

最新推荐文章于 2024-01-20 00:05:46 发布

阅读量546

点赞数

分类专栏： kbe

kbe 专栏收录该内容

8 篇文章 0 订阅

订阅专栏

https://bbs.comblockengine.com/forum.php?mod=viewthread&tid=2948

开源项目嘛大家了解了读懂了才敢用不然到时候出问题了不好排查；对于我这种从来没碰过服务器的还是很难理解的；抱着接受新事物的心态来读了下源码理解下流程，先读了下NetworkInterface

      NetworkInterface       {
            /*
                     NetworkInterface的流程

                     创建内网和外网两个socket终端(EndPoint)，并开始监听来自于客户端(或者其他内部服务器)的消息。
                     创建一个socekt响应事件ListenerReceiver 并将该socket终端(EndPoint) 通过epoll 与其绑定，来处理来自于客户端的连接

                     这样每当该socket终端(EndPoint)有客户端(或者内联的其他服务器)连接时，(已经注册过的客户端直接执行已经在epoll注册已经绑定的PacketReceiver处理packet数据)
                     新客户端连接就会调用epoll绑定的对应ListenerReceiver::handleInputNotification()
                     在handleInputNotification中accept该新客户端对应的的socket终端(EndPoint) ，
                     并将该socket终端封装到一个 Channel 来代表与该客户端的通信频道，这样所有的该客户端的事件都在其对应的的channel中处理，
                     创建PacketReceiver 来处理来自于各自客户端的事件，将该PacketReceiver与该链接EndPoint 绑定到epoll中，
                     这样每次客户端有消息来，就自动调用PacketReceiver,暂时放在该客户端对应的Channel中的addReceiveWindow放在 bufferedReceives_待处理
                     然后通过周期调用NetworkInterface::handleMainTick==>processChannels==>processPacket
                     ==>pPacketReader_->processMessages(pMsgHandlers, pPacket);==>pMsgHandler->handle(pChannel_, *pPacket);
                     在注册过的消息中搜索msgID来找到对应的句柄函数来处理该消息


                     主要的三个函数
                     构造函数中 : 创建内部链接和外部连接的监听函数，
                     recreateListeningSocket 用客户端的连接创建socket  将其与监听函数绑定到 epoll去处理

                     //定时处理所有注册过的Channel的绑定解除和处理
                     processChannels{
                              foreach (pChannel in channelMap)
                                    pChannel->processPackets(pMsgHandlers);
                     }

            */


            std::map<Address, Channel *>       ChannelMap;
            EndPoint extEndpoint_, intEndpoint_;
            DelayedChannels::Task;


            new ListenerReceiver *       pExtListenerReceiver_;
            new ListenerReceiver *       pIntListenerReceiver_;

            recreateListeningSocket;(const char* pEndPointName, uint16 listeningPort_min, uint16 listeningPort_max,
                                                                              const char * listeningInterface, EndPoint* pEP, ListenerReceiver* pLR, uint32 rbuffer,
                                                                              uint32 wbuffer)

            {
                     //http://www.cnblogs.com/dolphinX/p/3460545.html
                     pEP->socket(SOCK_STREAM);//create socket

                     //注册到 epoll ep为socket
                     //LR为ListenerReceiver即InputNotificationHandler；为epoll绑定的handler
                     //这样每当socket有客户端连接的时候 handler绑定的函数handleInputNotification 被执行
                     this->dispatcher().registerReadFileDescriptor(*pEP, pLR); --> pPoller_->registerForWrite(fd, handler);


                     pEP->bind(listeningPort, ifIPAddr)       //绑定网络地址

                     pEP->listen(backlog)                //开始监听

            }==
            //当socket有连接进来时会调用绑定的 ListenerReceiver  handleInputNotification
            ===>>>       int ListenerReceiver::handleInputNotification(int fd)
            {
                     EndPoint* pNewEndPoint = endpoint_.accept();//获取socket的连接事件  交给channel处理


                     Channel* pChannel = Network::Channel::ObjPool().createObject();

                     bool ret = pChannel->initialize(networkInterface_, pNewEndPoint, traits_){
                                    pPacketReceiver_ = new TCPPacketReceiver(*pEndPoint_, *pNetworkInterface_);

                                    //这里又将事件注册回epoll
                                    this->dispatcher().registerReadFileDescriptor(*pEndPoint_, pPacketReceiver_);

                                    /*       epoll接收到该客户端再次来的数据后
                                    对应的处理在TCPPacketReceiver{
                                    handleInputNotification{
                                             TCPPacketReceiver::processRecv(bool expectingPacket)
                                             {
                                                      TCPPacket* pReceiveWindow = TCPPacket::ObjPool().createObject();
                                                      int len = pReceiveWindow->recvFromEndPoint(*pEndpoint_);

                                                      Reason ret = this->processPacket(pChannel, pReceiveWindow)
                                                      {

                                                                     processFilteredPacket(pChannel, pPacket)
                                                                     {

                                                                                    pChannel->addReceiveWindow(pPacket)
                                                                                    {
                                                                                             //将客户端的消息放在了数组中待处理
                                                                                             bufferedReceives_.push_back(pPacket);

                                                                                    }

                                                                     }
                                                      }


                                             }


                                    }

                                    }*/


                              }

                     this.registerChannel pChannel
                     {
                              const Address & addr = pChannel->addr();
                              channelMap_[addr] = pChannel;
                     }

            }

            NetworkInterface::handleMainTick{
                     this.processChannels{
                              foreach (pChannel in channelMap_)
                                    pChannel->processPackets(pMsgHandlers);
                                    {

                                             pPacketReader_->processMessages(pMsgHandlers, pPacket);
                                             {
                                                      pMsgHandler->handle(pChannel_, *pPacket);
                                             }

                                    }

                     }
            }

      }

更新发送消息
/*
NetworkInterface的流程

创建内网和外网两个socket终端(EndPoint)，并开始监听来自于客户端(或者其他内部服务器)的消息。
创建一个socekt响应事件ListenerReceiver 并将该socket终端(EndPoint) 通过epoll 与其绑定，来处理来自于客户端的连接

这样每当该socket终端(EndPoint)有客户端(或者内联的其他服务器)连接时，(已经注册过的客户端直接执行已经在epoll注册已经绑定的PacketReceiver处理packet数据)
新客户端连接就会调用epoll绑定的对应ListenerReceiver::handleInputNotification()
在handleInputNotification中accept该新客户端对应的的socket终端(EndPoint) ，
并将该socket终端封装到一个 Channel 来代表与该客户端的通信频道，这样所有的该客户端的事件都在其对应的的channel中处理，
创建PacketReceiver 来处理来自于各自客户端的事件，将该PacketReceiver与该链接EndPoint 绑定到epoll中，
这样每次客户端有消息来，就自动调用PacketReceiver,暂时放在该客户端对应的Channel中的addReceiveWindow放在 bufferedReceives_待处理
然后通过周期调用NetworkInterface::handleMainTick==>processChannels==>processPacket
==>pPacketReader_->processMessages(pMsgHandlers, pPacket);==>pMsgHandler->handle(pChannel_, *pPacket);
在注册过的消息中搜索msgID来找到对应的句柄函数来处理该消息

而在服务器向外发送数据时候流程为
Channel::send==> pPacketSender_->processSend(this);
// 如果不能立即发送到系统缓冲区，那么交给poller处理PacketSender::handleOutputNotification==>processSend()??啥时候被触发呢?
==>TCPPacketSender::processPacket
==>processFilterPacket(pChannel, pPacket); ==>EndPoint* pEndpoint = pChannel->pEndPoint();
   pEndpoint->send();