MaNGOS-Zero源码学习之mangosd游戏逻辑服务器（二）：socket的处理方式

    本篇将介绍客户端与游戏逻辑服务器连接建立以后，mangosd如何接收、解析和处理客户端发过来的协议。本篇不再讨论mangosd与客户端的认证及建立最终RC4流加密的过程，想了解这部分内容请看该系列的第一篇。

 

 

一、acceptor socket的监听启动及注册

    mangosd的main ()函数调用单例对象sMaster的Run ()函数，启动监听socket的代码如下：

 

int Master::Run()
{
    ........

    ///- Launch the world listener socket
    uint16 wsport = sWorld.getConfig (CONFIG_UINT32_PORT_WORLD);
    std::string bind_ip = sConfig.GetStringDefault ("BindIP", "0.0.0.0");

    if (sWorldSocketMgr->StartNetwork (wsport, bind_ip) == -1)
    {
        sLog.outError ("Failed to start network");
        Log::WaitBeforeContinueIfNeed();
        World::StopNow(ERROR_EXIT_CODE);
        // go down and shutdown the server
    }

    sWorldSocketMgr->Wait ();

    ........
}

   

    mangosd用WorldSocketMgr类来管理socket。StartNetwork ()会调用StartReactiveIO ()来启动监听socket，处理代码如下：

int WorldSocketMgr::StartReactiveIO (ACE_UINT16 port, const char* address)
{
    ........

    //（1）
    m_NetThreadsCount = static_cast<size_t> (num_threads + 1);
    m_NetThreads = new ReactorRunnable[m_NetThreadsCount];

    // -1 means use default
    m_SockOutKBuff = sConfig.GetIntDefault ("Network.OutKBuff", -1);
    m_SockOutUBuff = sConfig.GetIntDefault ("Network.OutUBuff", 65536);
    if ( m_SockOutUBuff <= 0 )
    {
        sLog.outError ("Network.OutUBuff is wrong in your config file");
        return -1;
    }

    //（2）
    WorldSocket::Acceptor *acc = new WorldSocket::Acceptor;
    m_Acceptor = acc;

    ACE_INET_Addr listen_addr (port, address);
    if (acc->open (listen_addr, m_NetThreads[0].GetReactor (), ACE_NONBLOCK) == -1)
    {
        sLog.outError ("Failed to open acceptor ,check if the port is free");
        return -1;
    }

    //（3）
    for (size_t i = 0; i < m_NetThreadsCount; ++i)
        m_NetThreads[i].Start ();

    return 0;
}

（1）ReactorRunnable类继承了ACE_Task_Base，ACE_Task_Base 是ACE 中的任务或主动对象“处理结构”的基类。在ACE 中使用了此类来实现主动对象模式。所有希望成为“主动对象”的对象都必须从此类派生。可以把ACE_TASK 看作是更高级的、更为面向对象的线程类[1]。ACE_Task_Base调用时继承类必须重写svc方法，并且在使用时保证调用了activate ()方法。

（2）指定监听地址，端口并把Acceptor绑定到第一个线程的Reactor上。启动Acceptor开始监听网络IO。

（3）启动所有线程，每个线程上有一个单独的ACE_Reactor* m_Reactor;，这里的Reactor使用的是多线程的ACE_TP_Reactor。可以各自单独完成事件的多路复用。

 

 

二、线程体函数

    线程体函数ReactorRunnable::svc () 如下：

virtual int svc ()
{
    //（1）
    WorldDatabase.ThreadStart ();

    SocketSet::iterator i, t;
    while (!m_Reactor->reactor_event_loop_done ())
    {
        // dont be too smart to move this outside the loop
        // the run_reactor_event_loop will modify interval
        ACE_Time_Value interval (0, 10000);

        //（2）
        if (m_Reactor->run_reactor_event_loop (interval) == -1)
            break;

        //（3）
        AddNewSockets ();

        for (i = m_Sockets.begin (); i != m_Sockets.end ();)
        {
            //（4）
            if ((*i)->Update () == -1)
            {
                t = i;
                ++i;
                (*t)->CloseSocket ();
                (*t)->RemoveReference ();
                --m_Connections;
                m_Sockets.erase (t);
            }
            else
                ++i;
        }
    }

    WorldDatabase.ThreadEnd ();
    DEBUG_LOG ("Network Thread Exitting");

    return 0;
}

（1）会调用mysql_thread_init ()函数，初始化与该线程相关的变量。

（2）run_reactor_event_loop ()函数为多路复用的等待函数，当注册的事件发生、运行超时或者出现错误时返回。

（3）AddNewSockets ()函数会将缓存在m_NewSockets里的新到达的socket添加到SocketSet m_Sockets;里，同时检查并处理m_Sockets;里已经closed的socket。

（4）循环每一个WorldSocket，调用其Update ()方法，这里只处理每个socket的handle_output，即每个在此线程上的写事件，向客户端发送数据。下一节详细介绍：

 

 

三、WorldSocket::Update () 方法

    Update方法用于处理每个socket的输出：

int WorldSocket::Update (void)
{
    if (closing_)
        return -1;

    //（1）
    if (m_OutActive || m_OutBuffer->length () == 0)
        return 0;

    return handle_output (get_handle ());
}

（1）m_OutBuffer有数据时才会调用handle_output，handle_output ()用于处理输出，如果输出不能一次性做完，会调用schedule_wakeup_output ()再次激活write事件。当输出处理完毕后则调用cancel_wakeup_output ()取消激活write事件，使reactor恢复到正常的loop ()循环中。详细过程如下：

 

int WorldSocket::handle_output (ACE_HANDLE)
{
    //（1）
    ACE_GUARD_RETURN (LockType, Guard, m_OutBufferLock, -1);

    if (closing_)
        return -1;

    const size_t send_len = m_OutBuffer->length ();
    if (send_len == 0)
        return cancel_wakeup_output (Guard);

#ifdef MSG_NOSIGNAL
    ssize_t n = peer ().send (m_OutBuffer->rd_ptr (), send_len, MSG_NOSIGNAL);
#else
    ssize_t n = peer ().send (m_OutBuffer->rd_ptr (), send_len);
#endif // MSG_NOSIGNAL

    if (n == 0)
        return -1;
    else if (n == -1)
    {
        if (errno == EWOULDBLOCK || errno == EAGAIN) //----------（2）
            return schedule_wakeup_output (Guard);

        return -1;
    }
    else if (n < (ssize_t)send_len) //now n > 0      //----------（3）
    {
        m_OutBuffer->rd_ptr (static_cast<size_t> (n));

        // move the data to the base of the buffer
        m_OutBuffer->crunch ();

        return schedule_wakeup_output (Guard);
    }
    else //now n == send_len                         //----------（4）
    {
        m_OutBuffer->reset ();

        if (!iFlushPacketQueue ())
            return cancel_wakeup_output (Guard);
        else
            return schedule_wakeup_output (Guard);
    }

    ACE_NOTREACHED (return 0);
}

（1）对m_OutBuffer加锁。

（2）考虑信号打断的情况等，暂时不能写。

（3）只发送了部分数据则继续wakeup该线程对应的Reactor。

（4）检查m_OutBuffer数据发送完毕同时等待buffer（PacketQueueT m_PacketQueue;）里已经没有数据时，cancel wakeup让Reactor恢复正常。

 

 

四、socket到对应线程的指派

    上一节内容可以看到线程内如何处理socket，及新到达的socket。但从第一节中可知只有第一个线程注册为acceptor线程，那么新连接到达时，是如何被指派到对应的“接待”线程的呢？

    可以先看一下ACE_Acceptor的处理时序图：

图3.1 连接到达处理时序 [2]

   

    上图可以看出，当连接到达时，acceptor会调用对应的SVC_HANDLER的open ()函数，在mangosd里就是acceptor对应的int WorldSocket::open (void *a)，如下：

int WorldSocket::open (void *a)
{
    ........

    // Hook for the manager.
    if (sWorldSocketMgr->OnSocketOpen (this) == -1)
        return -1;

    ........
}

 

OnSocketOpen方法：

int WorldSocketMgr::OnSocketOpen (WorldSocket* sock)
{
    ........

    // we skip the Acceptor Thread
    size_t min = 1;

    MANGOS_ASSERT (m_NetThreadsCount >= 1);

    //（1）
    for (size_t i = 1; i < m_NetThreadsCount; ++i)
        if (m_NetThreads[i].Connections () < m_NetThreads[min].Connections ())
            min = i;

    return m_NetThreads[min].AddSocket (sock);
}

（1）将WorldSocket均衡的分配给每个线程。AddSocket ()将socket添加到m_NewSockets中做缓存，待该线程自行调用AddNewSockets ()添加到处理队列里。

 

  

总结：

    mangosd对socket的处理因为使用了ACE，逻辑处理代码相对比较简单，写事件的异常处理主要涉及

（1）一次不能写完则不断的wakeup Reactor。

（2）信号中断等错误的判断。似乎这里并没有考虑全面（见附录）

（3）使用另一个buffer缓存，因写缓存m_OutBuffer满而带来的多出的数据。

 

References：

[1] http://blog.csdn.net/yecao_kinux/article/details/1546914

[2] http://postfiles12.naver.net/data41/2009/4/11/187/33_kbkim007.jpg?type=w3

 

 

附录：

不同平台不同版本的read/write、send/recv有些不同，挺郁闷的一件事……………

EWOULDBLOCK：基于 berkeley 实现，当客户端异常终止连接时

ECONNABORTED：基于 posix 实现，当客户端异常终止连接时

EPROTO：基于 SVR4 实现，当客户端异常终止连接时）以及 EINTR