一個工業級、跨平臺、輕量級的 tcp 網路服務框架：gevent

作為公司的公共產品，經常有這樣的需求：就是新建一個本地服務，產品線作為客戶端通過 tcp 接入本地服務，來獲取想要的業務能力。

與印象中動輒處理成千上萬連線的 tcp 網路服務不同，這個本地服務是跑在客戶機器上的，Win32 上作為開機自啟動的 windows 服務執行；

Linux 上作為 daemon 在後臺執行。總的說來就是用於接收幾個產品程式的連線，因此輕量化是其最重要的要求，在這個基礎上要能兼顧跨平臺就可以了。

其實主要就是 windows，再兼顧一點兒 linux。

 

考察了幾個現有的開源網路框架，從 ACE 、boost::asio 到 libevent，都有不盡於人意的地方：

a) ACE：太重，只是想要一個網路框架，結果它扒拉扒拉一堆全提供了，不用還不行；

b) boost::asio：太複雜，牽扯到 boost 庫，並且引入了一堆 c++ 模板，需要高版本 c++ 編譯器支援；

c) libevent：這個看著不錯，當時確實用這個做底層封裝了一版，結果發版後發現一個比較致命的問題，導致在防火牆設定比較嚴格的機器上初始化失敗，這個後面我會詳細提到。

 

其它的就更不用說了，之前也粗略看過陳碩的 muddo，總的感覺吧，它是基於其它開源框架不足地方改進的一個庫，有相當可取的地方，但是這個改進的方向也主要是解決更大併發、更多連線，不是我的痛點，所以沒有繼續深入研究。

 

好了，與其在不同開源框架之間糾結，不如自己動手寫一個。

反正我的場景比較固定，不用像它們那樣面面俱，我給自己羅列了一些這個框架需要支援基本的功能：

1）同步寫、非同步讀；

2）可同時監聽多路事件，基於 1）這裡只針對非同步 READ 事件（包含連線進入、連線斷開），寫資料是同步的，因而不需要處理非同步 WRITE 事件；

3）要有設定一次性和週期性定時器的能力 （業務決定的）；

4）不需要處理訊號 （windows 上也沒訊號這一說，linux 自己搞搞 sigaction 就好啦）；

……

 

雖然這個框架未來只會執行在使用者的單機上，但是我不希望它一出生就帶有效能缺陷，所以效能平平的 select 沒能進入我的法眼，我決定給它裝上最強大的心臟：

Windows 平臺： iocp

Linux 平臺：epoll

 

ok，從需求到底層技術路線，貌似都講清楚了，依照 libevent 我給它取名為 gevent，下面我們從程式碼級別看下這個框架是怎麼簡化 tcp 服務搭建這類工作的。

首先看一下這個 tcp 服務框架的 sample：

svc_handler.h

#include "EventBase.h"
#include "EventHandler.h"

class GMyEventBase : public GEventBase
{
public:
    GEventHandler* create_handler (); 
}; 


class svc_handler : public GJsonEventHandler
{
public:
    virtual ~svc_handler () {}
    virtual void on_read_msg (Json::Value const& val); 
};

epoll_svc.cpp

#include <stdio.h>
#include "svc_handler.h"
#include <signal.h>

GMyEventBase g_base; 
GEventHandler* GMyEventBase::create_handler () 
{
    return new svc_handler; 
}

void sig_int (int signo)
{
    printf ("%d caught\n", signo); 
    g_base.exit (1); 
    printf ("exit ok\n"); 
}

int main (int argc, char *argv[])
{
    if (argc < 2)
    {
        printf ("usage: epoll_svc port\n"); 
        return -1; 
    }

    unsigned short port = atoi (argv[1]);

#ifndef WIN32
    struct sigaction act; 
    act.sa_handler = sig_int; 
    sigemptyset(&act.sa_mask);   
    act.sa_flags = SA_RESTART; 
    if (sigaction (SIGINT, &act, NULL) < 0)
    {
        printf ("install SIGINT failed, errno %d\n", errno); 
        return -1; 
    }
    else
        printf ("install SIGINT ok\n"); 
#endif

    // to test small message block
    if (g_base.init (/*8, 10*/) < 0)
        return -1; 

    printf ("init ok\n"); 
    do
    {
        if (!g_base.listen (port))
        {
            g_base.exit (0); 
            printf ("exit ok\n"); 
            break; 
        }

        printf ("listen ok\n"); 
        g_base.run (); 
        printf ("run  over\n"); 
    } while (0); 

    g_base.fini (); 
    printf ("fini ok\n"); 

    g_base.cleanup (); 
    printf ("cleanup ok\n"); 
    return 0; 
}

 

這個服務的核心是 GMyEventBase 類，它使用了框架中的 GEventBase 類，從後者派生而來，

只改寫了一個 create_handler 介面來提供我們的事件處理物件 svc_handler，它是從框架中的 GEventHandler 派生而來，

svc_handler 只改寫了一個 on_read_msg 來處理 Json 格式的訊息輸入。

 

程式的執行就是分別呼叫 GMyEventBase（實際上是GEventBase）  的 init / listen / run / fini / cleaup 方法。

而與業務相關的程式碼，都在 svc_handler 中處理：

svc_handler.cpp

#include "svc_handler.h"

void svc_handler::on_read_msg (Json::Value const& val)
{
    int key = val["key"].asInt (); 
    std::string data = val["data"].asString (); 
    printf ("got %d:%s\n", key, data.c_str ()); 

    Json::Value root; 
    Json::FastWriter writer; 
    root["key"] = key + 1; 
    root["data"] = data; 

    int ret = 0;
    std::string resp = writer.write(root); 
    resp = resp.substr (0, resp.length () - 1); // trim tailing \n
    if ((ret = send (resp)) <= 0)
        printf ("send response failed, errno %d\n", errno); 
    else 
        printf ("response %d\n", ret); 
}

 

它期待 Json 格式的資料，並且有兩個欄位 key(int) 與 data (string)，接收資料後將 key 增 1 後返回給客戶端。

再來看下客戶端 sample：

clt_handler.h

#include "EventBaseAR.h"
#include "EventHandler.h"

class GMyEventBase : public GEventBaseWithAutoReconnect
{
public:
    GEventHandler* create_handler (); 
}; 


class clt_handler : public GJsonEventHandler
{
public:
    virtual ~clt_handler () {}
#ifdef TEST_TIMER
    virtual bool on_timeout (GEV_PER_TIMER_DATA *gptd); 
#endif
    virtual void on_read_msg (Json::Value const& val); 
};

 

epoll_clt.cpp

#include <stdio.h>
#include "clt_handler.h"
#include <signal.h>

//#define TEST_READ
//#define TEST_CONN
//#define TEST_TIMER

GMyEventBase g_base; 
GEventHandler* GMyEventBase::create_handler () 
{
    return new clt_handler; 
}


int sig_caught = 0; 
void sig_int (int signo)
{
    sig_caught = 1; 
    printf ("%d caught\n", signo); 
    g_base.exit (0); 
    printf ("exit ok\n"); 
}

void do_read (GEventHandler *eh, int total)
{
    char buf[1024] = { 0 }; 
    int ret = 0, n = 0, key = 0, err = 0;
    char *ptr = nullptr; 
    while ((total == 0 ||  n++ < total) && fgets (buf, sizeof(buf), stdin) != NULL)
    {
        // skip \n
        buf[strlen(buf) - 1] = 0; 
        //n = sscanf (buf, "%d", &key); 
        key = strtol (buf, &ptr, 10); 
        if (ptr == nullptr)
        {
            printf ("format: int string\n"); 
            continue; 
        }

        Json::Value root; 
        Json::FastWriter writer; 
        root["key"] = key; 
        // skip space internal
        root["data"] = *ptr == ' ' ? ptr + 1 : ptr;  

        std::string req = writer.write (root); 
        req = req.substr (0, req.length () - 1); // trim tailing \n
        if ((ret = eh->send (req)) <= 0)
        {
            err = 1; 
            printf ("send %d failed, errno %d\n", req.length (), errno); 
            break; 
        }
        else 
            printf ("send %d\n", ret); 
    }

    if (total == 0)
        printf ("reach end\n"); 

    if (!err)
    {
        eh->disconnect (); 
        printf ("call disconnect to notify server\n"); 
    }

    // wait receiving thread 
    //sleep (3); 
    // if use press Ctrl+D, need to notify peer our break
}

#ifdef TEST_TIMER
void test_timer (unsigned short port, int period_msec, int times)
{
    int n = 0; 
    GEventHandler *eh = nullptr; 

    do
    {
        eh = g_base.connect (port); 
        if (eh == nullptr)
            break;

        printf ("connect ok\n"); 
        void* t = g_base.timeout (1000, period_msec, eh, NULL); 
        if (t == NULL)
        {
            printf ("timeout failed\n"); 
            break; 
        }
        else 
            printf ("set timer %p ok\n", t); 

        // to wait timer
        do
        {
            sleep (400); 
            printf ("wake up from sleep\n"); 
        } while (!sig_caught && n++ < times);

        g_base.cancel_timer (t); 
    } while (0); 
}
#endif

#ifdef TEST_CONN
void test_conn (unsigned short port, int per_read, int times)
{
#  ifdef WIN32
    srand (GetCurrentProcessId()); 
#  else
    srand (getpid ()); 
#  endif
    int n = 0, elapse = 0; 
    clt_handler *eh = nullptr; 

    do
    {
        eh = (clt_handler *)g_base.connect (port); 
        if (eh == nullptr)
            break;

        printf ("connect ok\n"); 

        do_read (eh, per_read); 
#  ifdef WIN32
        elapse = rand() % 1000; 
        Sleep(elapse); 
        printf ("running  %d ms\n", elapse); 
#  else
        elapse = rand () % 1000000; 
        usleep (elapse); 
        printf ("running  %.3f ms\n", elapse/1000.0); 
#  endif

    } while (!sig_caught && n++ < times);
}
#endif

#ifdef TEST_READ
void test_read (unsigned short port, int total)
{
    int n = 0; 
    GEventHandler *eh = nullptr; 

    do
    {
        eh = g_base.connect (port); 
        if (eh == nullptr)
            break;

        printf ("connect ok\n"); 
        do_read (eh, total); 
    } while (0); 
}
#endif

int main (int argc, char *argv[])
{
    if (argc < 2)
    {
        printf ("usage: epoll_clt port\n"); 
        return -1; 
    }

    unsigned short port = atoi (argv[1]); 

#ifndef WIN32
    struct sigaction act; 
    act.sa_handler = sig_int; 
    sigemptyset(&act.sa_mask);   
    // to ensure read be breaked by SIGINT
    act.sa_flags = 0; //SA_RESTART;  
    if (sigaction (SIGINT, &act, NULL) < 0)
    {
        printf ("install SIGINT failed, errno %d\n", errno); 
        return -1; 
    }
#endif

    if (g_base.init (2) < 0)
        return -1; 

    printf ("init ok\n"); 

#if defined(TEST_READ)
    test_read (port, 0); // 0 means infinite loop until user break
#elif defined(TEST_CONN)
    test_conn (port, 10, 100); 
#elif defined (TEST_TIMER)
    test_timer (port, 10, 1000); 
#else
#  error please define TEST_XXX macro to do something!
#endif

    if (!sig_caught)
    {
        // Ctrl + D ?
        g_base.exit (0); 
        printf ("exit ok\n"); 
    }
    else 
        printf ("has caught Ctrl+C\n"); 

    g_base.fini (); 
    printf ("fini ok\n"); 

    g_base.cleanup (); 
    printf ("cleanup ok\n"); 
    return 0; 
}

 

客戶端同樣使用了 GEventBase 的派生類 GMyEventBase 來作為事件迴圈的核心，所不同的是（注意並非之前例子裡的那個類，雖然同名），它提供了 clt_handler 來處理自己的業務程式碼。

另外為了提供連線中斷後自動向服務重連的功能，這裡 GMyEventBase 派生自 GEventBase 類的子類 GEventBaseWithAutoReconnect （位於 EventBaseAR.h/cpp 中）。

程式的執行是分別呼叫 GEventBase 的 init / connect / fini / cleaup 方法以及 GEventHandler 的 send / disconnect 來測試讀寫與連線。

定義巨集 TEST_READ 用來測試讀寫；定義巨集 TEST_CONN 可以測試連線的通斷及讀寫；定義巨集 TEST_TIMER 來測試周期性定時器及讀寫。它們是互斥的。

clt_handler 主要用來非同步接收服務端的回送資料並列印：

clt_handler.cpp

#include "clt_handler.h"

#ifdef TEST_TIMER
extern void do_read (clt_handler *, int); 
bool clt_handler::on_timeout (GEV_PER_TIMER_DATA *gptd)
{
    printf ("time out ! id %p, due %d, period %d\n", gptd, gptd->due_msec, gptd->period_msec); 
    do_read ((clt_handler *)gptd->user_arg, 1); 
    return true; 
}
#endif

void clt_handler::on_read_msg (Json::Value const& val)
{
    int key = val["key"].asInt (); 
    std::string data = val["data"].asString (); 
    printf ("got %d:%s\n", key, data.c_str ()); 
}

 

這個測試程式可以通過在控制檯手工輸入資料來驅動，也可以通過測試資料檔案來驅動，下面的 awk 指令碼用來製造符合格式的測試資料：

epoll_gen.awk

#! /bin/awk -f
BEGIN {
        WORDNUM = 1000
        for (i = 1; i <= WORDNUM; i++) {
                printf("%d %s\n", randint(WORDNUM), randword(20))
        }
}

# randint(n): return a random integer number which is >= 1 and <= n
function randint(n) {
        return int(n *rand()) + 1
}

# randlet(): return a random letter, which maybe upper, lower or number. 
function randlet() {
        return substr("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789", randint(62), 1)
}

# randword(LEN): return a rand word with a length of LEN
function randword(LEN) {
        randw=""
        for( j = 1; j <= LEN; j++) {
                randw=randw randlet()
        }
        return randw
}

 

生成的測試檔案格式如下：

238 s0jKlYkEjwE4q3nNJugF
568 0cgNaSgDpP3VS45x3Wum
996 kRF6SgmIReFmrNBcCecj
398 QHQqCrB5fC61hao1BV2x
945 XZ6KLtA4jZTEnhcAugAM
619 WE95NU7FnsYar4wz279j
549 oVCTmD516yvmtuJB2NG3
840 NDAaL5vpzp8DQX0rLRiV
378 jONIm64AN6UVc7uTLIIR
251 EqSBOhc40pKXhCbCu8Ey

 

整個工程編譯的話就是一個 CMakeLists 檔案，可以通過 cmake 生成對應的 Makefile 或 VS solution 來編譯程式碼：

CMakeLists.txt

cmake_minimum_required(VERSION 3.0)
project(epoll_svc)
include_directories(../core ../include)
set(CMAKE_CXX_FLAGS "-std=c++11 -pthread -g -Wall ${CMAKE_CXX_FLAGS}")
link_directories(${PROJECT_SOURCE_DIR}/../lib)
set(EXECUTABLE_OUTPUT_PATH ${PROJECT_SOURCE_DIR}/../bin)

add_executable (epoll_svc epoll_svc.cpp svc_handler.cpp ../core/EventBase.cpp ../core/EventHandler.cpp ../core/log.cpp)
IF (WIN32)
target_link_libraries(epoll_svc jsoncpp ws2_32)
ELSE ()
target_link_libraries(epoll_svc jsoncpp rt)
ENDIF ()

add_executable (epoll_clt epoll_clt.cpp clt_handler.cpp ../core/EventBase.cpp ../core/EventBaseAR.cpp ../core/EventHandler.cpp ../core/log.cpp)
target_compile_definitions(epoll_clt PUBLIC -D TEST_READ)
IF (WIN32)
target_link_libraries(epoll_clt jsoncpp ws2_32)
ELSE ()
target_link_libraries(epoll_clt jsoncpp rt)
ENDIF ()

add_executable (epoll_local epoll_local.cpp)
IF (WIN32)
target_link_libraries(epoll_local jsoncpp ws2_32)
ELSE ()
target_link_libraries(epoll_local jsoncpp rt)
ENDIF ()

 

 這個專案包含三個編譯目標，分別是 epoll_svc 、epoll_clt 與 epoll_local，其中前兩個可以跨平臺編譯，後一個只能在 Linux 平臺編譯，用來驗證 epoll 的一些特性。

編譯完成後，首先執行服務端：

>./epoll_svc 1025 

 然後執行客戶端：

>./epoll_clt 1025 < demo

測試多個客戶端同時連線，可以使用下面的指令碼：

epoll_start.sh

#! /bin/bash
# /bin/sh -> /bin/dash, do not recognize our for loop

for((i=0;i<10;i=i+1))
do
    ./epoll_clt 1025 < demo &
    echo "start $i"
done

 

可以同時啟動 10 個客戶端。

通過 Ctrl+C 退出服務端；通過 Ctrl+C 或 Ctrl+D 退出單個客戶端；

通過下面的指令碼來停止多個客戶端與服務端：

epoll_stop.sh

#! /bin/sh
pkill -INT epoll_clt
sleep 1
pkill -INT epoll_svc

 

---

 

框架的用法介紹完之後，再簡單遊覽一下這個庫的各層級對外介面。

EventBase.h

#pragma once


#include "EventHandler.h" 
#include <string>
#include <map>
#include <mutex> 
#include <condition_variable>
#include "thread_group.hpp"

#define GEV_MAX_BUF_SIZE 65536

class GEventBase : public IEventBase
{
public:
    GEventBase();
    ~GEventBase();

#ifdef WIN32
    virtual HANDLE iocp () const; 
#else
    virtual int epfd () const; 
#endif
    virtual bool post_timer(GEV_PER_TIMER_DATA *gptd); 
    virtual GEventHandler* create_handler() = 0; 

    // thr_num : 
    //  =0 - no default thread pool, user provide thread and call run
    //  <0 - use max(|thr_num|, processer_num)
    //  >0 - use thr_num
    bool init(int thr_num = -8, int blksize = GEV_MAX_BUF_SIZE
#ifndef WIN32
              , int timer_sig = SIGUSR1
#endif
              ); 

    bool listen(unsigned short port, unsigned short backup = 10);
    GEventHandler* connect(unsigned short port, GEventHandler* exist_handler = NULL); 
    // PARAM
    // due_msec: first timeout milliseconds
    // period_msec: later periodically milliseconds
    // arg: user provied argument
    // exist_handler: reuse the timer handler
    //
    // RETURN
    //   NULL: failed
    void* timeout(int due_msec, int period_msec, void *arg, GEventHandler *exist_handler);
    bool cancel_timer(void* tid); 
    void fini();  
    void run(); 
    void exit(int extra_notify = 0); 
    void cleanup(); 

protected:
#ifdef WIN32
    bool do_accept(GEV_PER_IO_DATA *gpid); 
    bool do_recv(GEV_PER_HANDLE_DATA *gphd, GEV_PER_IO_DATA *gpid); 
    void do_error(GEV_PER_HANDLE_DATA *gphd); 

    int init_socket();
    bool issue_accept(); 
    bool issue_read(GEV_PER_HANDLE_DATA *gphd);
    bool post_completion(DWORD bytes, ULONG_PTR key, LPOVERLAPPED ol); 

#else
    bool do_accept(int fd); 
    bool do_recv(conn_key_t key); 
    void do_error(conn_key_t key); 

    bool init_pipe(); 
    void close_pipe(); 
    bool post_notify (char ch, void* ptr = nullptr); 
    void promote_leader (std::unique_lock<std::mutex> &guard); 

    GEventHandler* find_by_key (conn_key_t key, bool erase); 
    GEventHandler* find_by_fd (int fd, conn_key_t &key, bool erase); 

#  ifdef HAS_SIGTHR
    void sig_proc (); 
#  endif
#endif

    bool do_timeout(GEV_PER_TIMER_DATA *gptd); 

    virtual bool on_accept(GEV_PER_HANDLE_DATA *gphd);
    virtual bool on_read(GEventHandler *h, GEV_PER_IO_DATA *gpid); 
    virtual void on_error(GEventHandler *h);
    virtual bool on_timeout (GEV_PER_TIMER_DATA *gptd); 
    

protected:
    volatile bool m_running = false;
    int m_thrnum = 0; 
    int m_blksize = GEV_MAX_BUF_SIZE; 
    std::thread_group m_grp; 
    SOCKET m_listener = INVALID_SOCKET;

    std::mutex m_mutex;  // protect m_map
    std::mutex m_tlock; // protect m_tmap
    // timer_t may conflict when new timer created after old timer closed
    //std::map <timer_t, GEventHandler *> m_tmap; 
    std::map <GEV_PER_TIMER_DATA*, GEventHandler *> m_tmap; 

#ifdef WIN32
    LPFN_ACCEPTEX m_acceptex = nullptr; 
    LPFN_GETACCEPTEXSOCKADDRS m_getacceptexsockaddrs = nullptr; 
    HANDLE m_iocp = NULL; 
    HANDLE m_timerque = NULL; 

    std::map<GEV_PER_HANDLE_DATA*, GEventHandler*> m_map; 
#else
    int m_ep = -1; 
    int m_pp[2]; 
    int m_tsig = 0; // signal number for timer

    std::mutex m_lock;   // protect epoll
    pthread_t m_leader = -1; 
    std::map<conn_key_t, GEventHandler*> m_map; 
#  ifdef HAS_SIGTHR
    // special thread only cares about signal
    std::thread *m_sigthr = nullptr; 
#  endif
#endif
};

 

• init，它在底層啟動 thr_num 個執行緒來跑 run 方法；每次 IO 的塊緩衝區大小由 blksize 指定；它內部還建立了對應的 iocp 或 epoll 物件，便於之後加入 socket 控制程式碼進行處理。
• exit，它通知執行緒池中的所有執行緒退出等待，windows 上是通過 PostQueuedCompletionStatus，Linux 上是通過在自建的一個 pipe 上寫資料以觸發 epoll 退出（這個 pipe 在 init 中建立並加入 epoll）；
• fini，它在所有工作執行緒退出後，關閉之前建立的物件，清理事件迴圈用到的資源；
• cleanup，它清理之前建立的 fd-handler 對映，清理遺留的處理器並釋放資源；
• run，它是執行緒池執行函式，windows 上是通過 GetQueuedCompletionStatus 在 iocp 上等待；在 linux 上是通過 epoll_wait 在 epoll 上等待事件。當有事件產生後，根據事件型別，分別呼叫 do_accept / on_accept、do_recv / on_read、do_error / on_error 回撥來分派事件；
• listen，建立偵聽 socket 並加入到 iocp 或 epoll 中；
• connect，連線到遠端服務並將成功連線的 socket 加入到 iocp 或  epoll 中；
• timeout，設定定時器事件，windows 上是通過 CreateTimerQueueTimer 實現定時器超時；linux 則是通過 timer_create 實現的，都是系統現成的東西，只不過在系統定時器到期後，給對應的 iocp 或 epoll 物件傳送了一個通知而已，在 linux 上這個通知機制是上面提到過的 pipe 來實現的，因而有一定延遲，不能指定精度太小的定時器；
• cancel_timer，取消之前設定的定時器。

 

然後看下 GEventHandler 提供的回撥介面，應用可以從它派生並完成業務相關程式碼：

EventHandler.h

#pragma once
#include "platform.h"

#ifdef WIN32
// must ensure <winsock2.h> precedes <widnows.h> included, to prevent winsock2.h conflict with winsock.h
#  include <WinSock2.h>
#  include <Windows.h>
#  include <mswsock.h>  // for LPFN_ACCEPTEX & LPFN_GETACCEPTEXSOCKADDRS later in EventBase.h
#else
#  include <unistd.h> // for close
#  include <sys/socket.h>
#  include <sys/epoll.h>
#  include <sys/time.h>
#  include <netinet/in.h> // for struct sockaddr_in
#  include <arpa/inet.h> // for inet_addr/inet_ntoa
#  include <string.h> // for memset/memcpy
#  include <signal.h>
#endif

#include <mutex>
#include "jsoncpp/json.h"


class GEventHandler; 
struct GEV_PER_TIMER_DATA; 
class IEventBase
{
public:
#ifdef WIN32
    virtual HANDLE iocp () const = 0; 
#else
    virtual int epfd () const = 0; 
#endif

    virtual void* timeout(int due_msec, int period_msec, void *arg, GEventHandler *exist_handler) = 0; 
    virtual bool cancel_timer(void* tid) = 0; 
    virtual bool post_timer(GEV_PER_TIMER_DATA *gptd) = 0; 
};


#ifdef WIN32
enum GEV_IOCP_OP
{
    OP_TIMEOUT = 1, 
    OP_ACCEPT,
    OP_RECV,
};
#else 
// the purpose of this key is to distinguish different connections with same fd !
// (when connection break and re-established soon, fd may not change but port will change)
struct conn_key_t
{
    int fd; 
    unsigned short lport; 
    unsigned short rport; 

    conn_key_t (int f, unsigned short l, unsigned short r); 
    bool operator< (struct conn_key_t const& rhs) const; 
}; 
#endif


struct GEV_PER_HANDLE_DATA
{
    SOCKET so;
    SOCKADDR_IN laddr;
    SOCKADDR_IN raddr;

#ifndef WIN32
    conn_key_t key () const; 
#endif

    GEV_PER_HANDLE_DATA(SOCKET s, SOCKADDR_IN *l, SOCKADDR_IN *r); 
    virtual ~GEV_PER_HANDLE_DATA(); 
};

struct GEV_PER_IO_DATA
{
    SOCKET so;
#ifdef WIN32
    GEV_IOCP_OP op;
    OVERLAPPED ol;
    WSABUF wsa;         // wsa.len is buffer length
    DWORD bytes;        // after compeleted, bytes trasnfered
#else
    char *buf; 
    int len; 
#endif

    GEV_PER_IO_DATA(
#ifdef WIN32
            GEV_IOCP_OP o, 
#endif
            SOCKET s, int l); 
    virtual ~GEV_PER_IO_DATA(); 
};

struct GEV_PER_TIMER_DATA
#ifdef WIN32
       : public GEV_PER_IO_DATA
#endif
{
    IEventBase *base; 
    int due_msec; 
    int period_msec; 
    void *user_arg;
    bool cancelled;
#ifdef WIN32
    HANDLE timerque; 
    HANDLE timer; 
#else
    timer_t timer; 
#endif

    GEV_PER_TIMER_DATA(IEventBase *base, int due, int period, void *arg
#ifdef WIN32
            , HANDLE tq);
#else
            , timer_t tid); 
#endif

    virtual ~GEV_PER_TIMER_DATA(); 
    void cancel (); 
};

class GEventHandler
{
public:
    GEventHandler();
    virtual ~GEventHandler();

    GEV_PER_HANDLE_DATA* gphd(); 
    GEV_PER_TIMER_DATA* gptd(); 
    bool connected();
    void disconnect(); 
    void clear(); 
    SOCKET fd(); 

    int send(char const* buf, int len);
    int send(std::string const& str);
    
    virtual bool reuse();
    virtual bool auto_reconnect();
    virtual void arg(void *param) = 0;
    virtual void reset(GEV_PER_HANDLE_DATA *gphd, GEV_PER_TIMER_DATA *gptd, IEventBase *base);
    virtual bool on_read(GEV_PER_IO_DATA *gpid) = 0;
    virtual void on_error(GEV_PER_HANDLE_DATA *gphd); 
    // note when on_timeout called, handler's base may cleared by cancel_timer, use gptd->base instead if it is not null.
    virtual bool on_timeout(GEV_PER_TIMER_DATA *gptd) = 0; 
    virtual void cleanup(bool terminal);
    void close(bool terminal);

protected:
    GEV_PER_HANDLE_DATA *m_gphd = nullptr; 
    GEV_PER_TIMER_DATA *m_gptd = nullptr; 
    IEventBase *m_base = nullptr;
    // us so instead of m_gphd, 
    // as the later one may destroyed during using..
    SOCKET m_so;
};

// a common handler to process json protocol.
class GJsonEventHandler : public GEventHandler
{
public:
    //virtual void on_read();
    virtual void arg(void *param);
    virtual void reset(GEV_PER_HANDLE_DATA *gphd, GEV_PER_TIMER_DATA *gptd, IEventBase *base);
    virtual bool on_read(GEV_PER_IO_DATA *gpid);
    virtual void on_read_msg(Json::Value const& root) = 0;
    virtual bool on_timeout(GEV_PER_TIMER_DATA *gptd);
    virtual void cleanup(bool terminal);

protected:
    // protect m_stub to prevent multi-entry
#ifdef HAS_ET
    std::mutex m_mutex; 
#endif

    std::string m_stub;
};

 

這裡主要有兩個類，GEventHandler 處理通用的基於流的資料；GJsonEventHandler 處理基於 json 格式的資料。

前者需要重寫 on_read 方法來處理塊資料；後者需要重寫 on_read_msg 方法來處理 json 資料。

目前 json 的解析是通過 jsoncpp 庫完成的，這個庫本身是跨平臺的（本 git 庫僅提供 64 位 Linux 靜態連結庫及 VS2013 的 32 位 Release 版本 Windows 靜態庫）。

svc_handler 與 clt_handler  均從 GJsonEventHandler 派生。

如果有新的流格式需要處理 ，只需要從 GEventHandler 類派生新的處理類即可。

 

除了讀取連線上的資料，還有其它一些重要的回撥介面，列明如下：

• on_read，連線上有資料到達；
• on_error，連線斷開；
• on_tmeout，定時器事件；
• ……

如果有新的事件需要處理 ，也可以在這裡擴充套件。

最後看下 GEventBaseWithAutoReconnect 提供的與自動重連相關的介面：

EventBaseAR.h

#pragma once


#include "EventBase.h"
#include <thread>

#define GEV_RECONNECT_TIMEOUT 2 // seconds
#define GEV_MAX_RECONNECT_TIMEOUT 256 // seconds

class GEventBaseWithAutoReconnect : public GEventBase
{
public:
    GEventBaseWithAutoReconnect(int reconn_min = GEV_RECONNECT_TIMEOUT, int reconn_max = GEV_MAX_RECONNECT_TIMEOUT);
    ~GEventBaseWithAutoReconnect();

    bool do_connect(unsigned short port, void *arg);
    GEventHandler* connector(); 

protected:
    virtual void on_error(GEventHandler *h);
    virtual bool on_timeout(GEV_PER_TIMER_DATA *gptd);

    virtual void on_connect_break(); 
    virtual bool on_connected(GEventHandler *app);

protected:
    void do_reconnect(void *arg);

protected:
    unsigned short m_port; 
    GEventHandler* m_app;
    GEventHandler* m_htimer; 
    void* m_timer;
    int m_reconn_min; 
    int m_reconn_max; 
    int m_reconn_curr;
};

 

其實比較簡單，只比 GEventBase 類多了一個  do_connect 方法，來擴充套件 connect 不能自動重連的問題。

底層的話，是通過定時器來實現指數後退重連演算法的。

 

---

 

後記

這個框架已經應用到我司的公共產品中，併為數個 tcp 服務提供底層支撐，經過百萬級別使用者機器驗證，執行穩定性還是可以的，所以當得起“工業級”這三個字。

 

前面在說到開源庫的選型時還留了一個口子沒有交待，這裡一併說下。

其實最早的重構版本是使用 libevent 來實現的，但是發現它在 windows 上使用的是低效的 select，

而且為了增加、刪除控制程式碼，它又使用了一種 self-pipe-trick 的技巧，簡單說來的就是下面的程式碼序列：

listen (listen_fd, 1); 
……
connect (connect_fd, &addr, size); 
……
accept_fd = accept (listen_fd, &addr, &size); 

 

在缺乏 pipe 呼叫的 win32 環境製造了一個 socket 自連線，從而進行一些通知。

這一步是必要的，如果不能成功連線就會導致整個 libevent 初始化失敗，從而執行不起來。

不巧的是，在一些 windows 機器上（約佔使用者總量 10%），由於防火牆設定嚴格，上述 listen 與 connect 呼叫可以成功，

但是 accept 會失敗返回，從而導致整個服務退出 （防火牆會嚴格禁止不在白名單上偵聽的埠的連線）。

對於已知埠，可以通過在防火牆上設定白名單來避免，但是對於這種隨機 listen 的埠，真的是太難了，基本無解。

 

回頭考察了一下 asio，windows 上使用的是 iocp，自然沒有這個自連線；

ACE 有多種實現可供選擇，如果使用  ACE_Select_Reactor / ACE_TP_Reactor 是會有這個自連線，

但是你可以選擇其它實現，如基於 WaitForMultipleEvents 的 ACE_WFMO_Reactor（最大隻支援 62 個控制程式碼，放棄），

或基於 iocp 的 ACE_Proactor （前攝式，與反應式在程式設計上稍有不同，更接近於 asio）就沒有這個自連線。

 

再說的深一點，其實公司最早的網路庫使用的就是基於 boost 的 asio，大量的使用了 c++ 模板，

有時候產生了一些崩潰，但是根據 dump 完全無法定位崩潰點（各種冗長的模板展開名稱），

導致了一些頑固的已知 bug 一起找不到崩潰點而無法解決（雖然量不大），所以才有了要去重新選型網路庫以及後來這一系列的東西。

 

本來一開始我是想用 ACE 的，因為我讀過這個庫的原始碼，對裡面所有的東西都非常熟悉，

但是看看 ACE 小 5 MB 的 dll 尺寸，還是放棄了（產品本身安裝包也就這麼大吧），

對於一個公司底層的公共元件，被各種產品攜帶，需要嚴格控制“體重”

（後來聽說 ACE 按功能拆分了程式碼模組，你只需要選自己依賴的部分即可，不過我還沒有試過）。

 

使用這個庫代替之前的 boost::asio 後，我還有一個意外收穫，就是編譯出來的 dll 尺寸明顯小了很多，700 K -> 500 K 的樣子，看來所謂模板膨脹是真有其事……

 

最後奉上 gevent 的 github 連結，歡迎有相同需求的小夥伴前來“復刻” ：

https://github.com/goodpaperman/gevent