一個工業級、跨平臺、輕量級的 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
複製代碼
1 #include “EventBase.h”
2 #include “EventHandler.h”
3
4 class GMyEventBase : public GEventBase
5 {
6 public:
7 GEventHandler* create_handler ();
8 };
9
10
11 class svc_handler : public GJsonEventHandler
12 {
13 public:
14 virtual ~svc_handler () {}
15 virtual void on_read_msg (Json::Value const& val);
16 };
複製代碼
epoll_svc.cpp
複製代碼
1 #include <stdio.h>
2 #include “svc_handler.h”
3 #include <signal.h>
4
5 GMyEventBase g_base;
6 GEventHandler* GMyEventBase::create_handler ()
7 {
8 return new svc_handler;
9 }
10
11 void sig_int (int signo)
12 {
13 printf ("%d caught\n", signo);
14 g_base.exit (1);
15 printf (“exit ok\n”);
16 }
17
18 int main (int argc, char *argv[])
19 {
20 if (argc < 2)
21 {
22 printf (“usage: epoll_svc port\n”);
23 return -1;
24 }
25
26 unsigned short port = atoi (argv[1]);
27
28 #ifndef WIN32
29 struct sigaction act;
30 act.sa_handler = sig_int;
31 sigemptyset(&act.sa_mask);
32 act.sa_flags = SA_RESTART;
33 if (sigaction (SIGINT, &act, NULL) < 0)
34 {
35 printf (“install SIGINT failed, errno %d\n”, errno);
36 return -1;
37 }
38 else
39 printf (“install SIGINT ok\n”);
40 #endif
41
42 // to test small message block
43 if (g_base.init (/8, 10/) < 0)
44 return -1;
45
46 printf (“init ok\n”);
47 do
48 {
49 if (!g_base.listen (port))
50 {
51 g_base.exit (0);
52 printf (“exit ok\n”);
53 break;
54 }
55
56 printf (“listen ok\n”);
57 g_base.run ();
58 printf (“run over\n”);
59 } while (0);
60
61 g_base.fini ();
62 printf (“fini ok\n”);
63
64 g_base.cleanup ();
65 printf (“cleanup ok\n”);
66 return 0;
67 }
複製代碼
這個效勞的中心是 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
複製代碼
1 #include “svc_handler.h”
2
3 void svc_handler::on_read_msg (Json::Value const& val)
4 {
5 int key = val[“key”].asInt ();
6 std::string data = val[“data”].asString ();
7 printf (“got %d:%s\n”, key, data.c_str ());
8
9 Json::Value root;
10 Json::FastWriter writer;
11 root[“key”] = key + 1;
12 root[“data”] = data;
13
14 int ret = 0;
15 std::string resp = writer.write(root);
16 resp = resp.substr (0, resp.length () - 1); // trim tailing \n
17 if ((ret = send (resp)) <= 0)
18 printf (“send response failed, errno %d\n”, errno);
19 else
20 printf (“response %d\n”, ret);
21 }
複製代碼
它等候 Json 格式的數據，並且有兩個字段 key(int) 與 data (string)，接納數據後將 key 增 1 後返回給客戶端。
再來看下客戶端 sample：
clt_handler.h
複製代碼
1 #include “EventBaseAR.h”
2 #include “EventHandler.h”
3
4 class GMyEventBase : public GEventBaseWithAutoReconnect
5 {
6 public:
7 GEventHandler* create_handler ();
8 };
9
10
11 class clt_handler : public GJsonEventHandler
12 {
13 public:
14 virtual ~clt_handler () {}
15 #ifdef TEST_TIMER
16 virtual bool on_timeout (GEV_PER_TIMER_DATA *gptd);
17 #endif
18 virtual void on_read_msg (Json::Value const& val);
19 };
複製代碼
epoll_clt.cpp
複製代碼
1 #include <stdio.h>
2 #include “clt_handler.h”
3 #include <signal.h>
4
5 //#define TEST_READ
6 //#define TEST_CONN
7 //#define TEST_TIMER
8
9 GMyEventBase g_base;
10 GEventHandler* GMyEventBase::create_handler ()
11 {
12 return new clt_handler;
13 }
14
15
16 int sig_caught = 0;
17 void sig_int (int signo)
18 {
19 sig_caught = 1;
20 printf ("%d caught\n", signo);
21 g_base.exit (0);
22 printf (“exit ok\n”);
23 }
24
25 void do_read (GEventHandler *eh, int total)
26 {
27 char buf[1024] = { 0 };
28 int ret = 0, n = 0, key = 0, err = 0;
29 char *ptr = nullptr;
30 while ((total == 0 || n++ < total) && fgets (buf, sizeof(buf), stdin) != NULL)
31 {
32 // skip \n
33 buf[strlen(buf) - 1] = 0;
34 //n = sscanf (buf, “%d”, &key);
35 key = strtol (buf, &ptr, 10);
36 if (ptr == nullptr)
37 {
38 printf (“format: int string\n”);
39 continue;
40 }
41
42 Json::Value root;
43 Json::FastWriter writer;
44 root[“key”] = key;
45 // skip space internal
46 root[“data”] = *ptr == ’ ’ ? ptr + 1 : ptr;
47
48 std::string req = writer.write (root);
49 req = req.substr (0, req.length () - 1); // trim tailing \n
50 if ((ret = eh->send (req)) <= 0)
51 {
52 err = 1;
53 printf (“send %d failed, errno %d\n”, req.length (), errno);
54 break;
55 }
56 else
57 printf (“send %d\n”, ret);
58 }
59
60 if (total == 0)
61 printf (“reach end\n”);
62
63 if (!err)
64 {
65 eh->disconnect ();
66 printf (“call disconnect to notify server\n”);
67 }
68
69 // wait receiving thread
70 //sleep (3);
71 // if use press Ctrl+D, need to notify peer our break
72 }
73
74 #ifdef TEST_TIMER
75 void test_timer (unsigned short port, int period_msec, int times)
76 {
77 int n = 0;
78 GEventHandler eh = nullptr;
79
80 do
81 {
82 eh = g_base.connect (port);
83 if (eh == nullptr)
84 break;
85
86 printf (“connect ok\n”);
87 void t = g_base.timeout (1000, period_msec, eh, NULL);
88 if (t == NULL)
89 {
90 printf (“timeout failed\n”);
91 break;
92 }
93 else
94 printf (“set timer %p ok\n”, t);
95
96 // to wait timer
97 do
98 {
99 sleep (400);
100 printf (“wake up from sleep\n”);
101 } while (!sig_caught && n++ < times);
102
103 g_base.cancel_timer (t);
104 } while (0);
105 }
106 #endif
107
108 #ifdef TEST_CONN
109 void test_conn (unsigned short port, int per_read, int times)
110 {
111 # ifdef WIN32
112 srand (GetCurrentProcessId());
113 # else
114 srand (getpid ());
115 # endif
116 int n = 0, elapse = 0;
117 clt_handler *eh = nullptr;
118
119 do
120 {
121 eh = (clt_handler *)g_base.connect (port);
122 if (eh == nullptr)
123 break;
124
125 printf (“connect ok\n”);
126
127 do_read (eh, per_read);
128 # ifdef WIN32
129 elapse = rand() % 1000;
130 Sleep(elapse);
131 printf (“running %d ms\n”, elapse);
132 # else
133 elapse = rand () % 1000000;
134 usleep (elapse);
135 printf (“running %.3f ms\n”, elapse/1000.0);
136 # endif
137
138 } while (!sig_caught && n++ < times);
139 }
140 #endif
141
142 #ifdef TEST_READ
143 void test_read (unsigned short port, int total)
144 {
145 int n = 0;
146 GEventHandler *eh = nullptr;
147
148 do
149 {
150 eh = g_base.connect (port);
151 if (eh == nullptr)
152 break;
153
154 printf (“connect ok\n”);
155 do_read (eh, total);
156 } while (0);
157 }
158 #endif
159
160 int main (int argc, char *argv[])
161 {
162 if (argc < 2)
163 {
164 printf (“usage: epoll_clt port\n”);
165 return -1;
166 }
167
168 unsigned short port = atoi (argv[1]);
169
170 #ifndef WIN32
171 struct sigaction act;
172 act.sa_handler = sig_int;
173 sigemptyset(&act.sa_mask);
174 // to ensure read be breaked by SIGINT
175 act.sa_flags = 0; //SA_RESTART;
176 if (sigaction (SIGINT, &act, NULL) < 0)
177 {
178 printf (“install SIGINT failed, errno %d\n”, errno);
179 return -1;
180 }
181 #endif
182
183 if (g_base.init (2) < 0)
184 return -1;
185
186 printf (“init ok\n”);
187
188 #if defined(TEST_READ)
189 test_read (port, 0); // 0 means infinite loop until user break
190 #elif defined(TEST_CONN)
191 test_conn (port, 10, 100);
192 #elif defined (TEST_TIMER)
193 test_timer (port, 10, 1000);
194 #else
195 # error please define TEST_XXX macro to do something!
196 #endif
197
198 if (!sig_caught)
199 {
200 // Ctrl + D ?
201 g_base.exit (0);
202 printf (“exit ok\n”);
203 }
204 else
205 printf (“has caught Ctrl+C\n”);
206
207 g_base.fini ();
208 printf (“fini ok\n”);
209
210 g_base.cleanup ();
211 printf (“cleanup ok\n”);
212 return 0;
213 }
複製代碼
客戶端同樣運用了 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
複製代碼
1 #include “clt_handler.h”
2
3 #ifdef TEST_TIMER
4 extern void do_read (clt_handler *, int);
5 bool clt_handler::on_timeout (GEV_PER_TIMER_DATA *gptd)
6 {
7 printf (“time out ! id %p, due %d, period %d\n”, gptd, gptd->due_msec, gptd->period_msec);
8 do_read ((clt_handler *)gptd->user_arg, 1);
9 return true;
10 }
11 #endif
12
13 void clt_handler::on_read_msg (Json::Value const& val)
14 {
15 int key = val[“key”].asInt ();
16 std::string data = val[“data”].asString ();
17 printf (“got %d:%s\n”, key, data.c_str ());
18 }
複製代碼
這個測試程序可以經過在控制檯手工輸入數據來驅動，也可以經過測試數據文件來驅動，下面的 awk 腳本用來製造契合格式的測試數據：
epoll_gen.awk
複製代碼
1 #! /bin/awk -f
2 BEGIN {
3 WORDNUM = 1000
4 for (i = 1; i <= WORDNUM; i++) {
5 printf("%d %s\n", randint(WORDNUM), randword(20))
6 }
7 }
8
9 # randint(n): return a random integer number which is >= 1 and <= n
10 function randint(n) {
11 return int(n *rand()) + 1
12 }
13
14 # randlet(): return a random letter, which maybe upper, lower or number.
15 function randlet() {
16 return substr(“abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789”, randint(62), 1)
17 }
18
19 # randword(LEN): return a rand word with a length of LEN
20 function randword(LEN) {
21 randw=""
22 for( j = 1; j <= LEN; j++) {
23 randw=randw randlet()
24 }
25 return randw
26 }
複製代碼
生成的測試文件格式如下：
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
複製代碼
1 cmake_minimum_required(VERSION 3.0)
2 project(epoll_svc)
3 include_directories(…/core …/include)
4 set(CMAKE_CXX_FLAGS "-std=c++11 -pthread -g -Wall {PROJECT_SOURCE_DIR}/…/lib)
6 set(EXECUTABLE_OUTPUT_PATH ${PROJECT_SOURCE_DIR}/…/bin)
7
8 add_executable (epoll_svc epoll_svc.cpp svc_handler.cpp …/core/EventBase.cpp …/core/EventHandler.cpp …/core/log.cpp)
9 IF (WIN32)
10 target_link_libraries(epoll_svc jsoncpp ws2_32)
11 ELSE ()
12 target_link_libraries(epoll_svc jsoncpp rt)
13 ENDIF ()
14
15 add_executable (epoll_clt epoll_clt.cpp clt_handler.cpp …/core/EventBase.cpp …/core/EventBaseAR.cpp …/core/EventHandler.cpp …/core/log.cpp)
16 target_compile_definitions(epoll_clt PUBLIC -D TEST_READ)
17 IF (WIN32)
18 target_link_libraries(epoll_clt jsoncpp ws2_32)
19 ELSE ()
20 target_link_libraries(epoll_clt jsoncpp rt)
21 ENDIF ()
22
23 add_executable (epoll_local epoll_local.cpp)
24 IF (WIN32)
25 target_link_libraries(epoll_local jsoncpp ws2_32)
26 ELSE ()
27 target_link_libraries(epoll_local jsoncpp rt)
28 ENDIF ()
複製代碼
這個項目包含三個編譯目的，分別是 epoll_svc 、epoll_clt 與 epoll_local，其中前兩個可以跨平臺編譯，後一個只能在 Linux 平臺編譯，用來考證 epoll 的一些特性。
編譯完成後，首先運轉效勞端：
./epoll_svc 1025
然後運轉客戶端：
./epoll_clt 1025 < demo
測試多個客戶端同時銜接，可以運用下面的腳本：
epoll_start.sh
複製代碼
1 #! /bin/bash
2 # /bin/sh -> /bin/dash, do not recognize our for loop
3
4 for((i=0;i<10;i=i+1))
5 do
6 ./epoll_clt 1025 < demo &
7 echo “start $i”
8 done
複製代碼
可以同時啓動 10 個客戶端。
經過 Ctrl+C 退出效勞端；經過 Ctrl+C 或 Ctrl+D 退出單個客戶端；
經過下面的腳本來中止多個客戶端與效勞端：
epoll_stop.sh
1 #! /bin/sh
2 pkill -INT epoll_clt
3 sleep 1
4 pkill -INT epoll_svc
框架的用法引見完之後，再簡單旅遊一下這個庫的各層級對外接口。
EventBase.h
複製代碼
1 #pragma once
2
3
4 #include “EventHandler.h”
5 #include
6 #include
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
複製代碼
1 #pragma once
2 #include “platform.h”
3
4 #ifdef WIN32
5 // must ensure <winsock2.h> precedes <widnows.h> included, to prevent winsock2.h conflict with winsock.h
6 # include <WinSock2.h>
7 # include <Windows.h>
8 # include <mswsock.h> // for LPFN_ACCEPTEX & LPFN_GETACCEPTEXSOCKADDRS later in EventBase.h
9 #else
10 # include <unistd.h> // for close
11 # include <sys/socket.h>
12 # include <sys/epoll.h>
13 # include <sys/time.h>
14 # include <netinet/in.h> // for struct sockaddr_in
15 # include <arpa/inet.h> // for inet_addr/inet_ntoa
16 # include <string.h> // for memset/memcpy
17 # include <signal.h>
18 #endif
19
20 #include
21 #include “jsoncpp/json.h”
22
23
24 class GEventHandler;
25 struct GEV_PER_TIMER_DATA;
26 class IEventBase
27 {
28 public:
29 #ifdef WIN32
30 virtual HANDLE iocp () const = 0;
31 #else
32 virtual int epfd () const = 0;
33 #endif
34
35 virtual void* timeout(int due_msec, int period_msec, void *arg, GEventHandler exist_handler) = 0;
36 virtual bool cancel_timer(void tid) = 0;
37 virtual bool post_timer(GEV_PER_TIMER_DATA *gptd) = 0;
38 };
39
40
41 #ifdef WIN32
42 enum GEV_IOCP_OP
43 {
44 OP_TIMEOUT = 1,
45 OP_ACCEPT,
46 OP_RECV,
47 };
48 #else
49 // the purpose of this key is to distinguish different connections with same fd !
50 // (when connection break and re-established soon, fd may not change but port will change)
51 struct conn_key_t
52 {
53 int fd;
54 unsigned short lport;
55 unsigned short rport;
56
57 conn_key_t (int f, unsigned short l, unsigned short r);
58 bool operator< (struct conn_key_t const& rhs) const;
59 };
60 #endif
61
62
63 struct GEV_PER_HANDLE_DATA
64 {
65 SOCKET so;
66 SOCKADDR_IN laddr;
67 SOCKADDR_IN raddr;
68
69 #ifndef WIN32
70 conn_key_t key () const;
71 #endif
72
73 GEV_PER_HANDLE_DATA(SOCKET s, SOCKADDR_IN *l, SOCKADDR_IN *r);
74 virtual ~GEV_PER_HANDLE_DATA();
75 };
76
77 struct GEV_PER_IO_DATA
78 {
79 SOCKET so;
80 #ifdef WIN32
81 GEV_IOCP_OP op;
82 OVERLAPPED ol;
83 WSABUF wsa; // wsa.len is buffer length
84 DWORD bytes; // after compeleted, bytes trasnfered
85 #else
86 char *buf;
87 int len;
88 #endif
89
90 GEV_PER_IO_DATA(
91 #ifdef WIN32
92 GEV_IOCP_OP o,
93 #endif
94 SOCKET s, int l);
95 virtual ~GEV_PER_IO_DATA();
96 };
97
98 struct GEV_PER_TIMER_DATA
99 #ifdef WIN32
100 : public GEV_PER_IO_DATA
101 #endif
102 {
103 IEventBase *base;
104 int due_msec;
105 int period_msec;
106 void user_arg;
107 bool cancelled;
108 #ifdef WIN32
109 HANDLE timerque;
110 HANDLE timer;
111 #else
112 timer_t timer;
113 #endif
114
115 GEV_PER_TIMER_DATA(IEventBase base, int due, int period, void arg
116 #ifdef WIN32
117 , HANDLE tq);
118 #else
119 , timer_t tid);
120 #endif
121
122 virtual ~GEV_PER_TIMER_DATA();
123 void cancel ();
124 };
125
126 class GEventHandler
127 {
128 public:
129 GEventHandler();
130 virtual ~GEventHandler();
131
132 GEV_PER_HANDLE_DATA gphd();
133 GEV_PER_TIMER_DATA gptd();
134 bool connected();
135 void disconnect();
136 void clear();
137 SOCKET fd();
138
139 int send(char const buf, int len);
140 int send(std::string const& str);
141
142 virtual bool reuse();
143 virtual bool auto_reconnect();
144 virtual void arg(void *param) = 0;
145 virtual void reset(GEV_PER_HANDLE_DATA *gphd, GEV_PER_TIMER_DATA *gptd, IEventBase *base);
146 virtual bool on_read(GEV_PER_IO_DATA *gpid) = 0;
147 virtual void on_error(GEV_PER_HANDLE_DATA *gphd);
148 // note when on_timeout called, handler’s base may cleared by cancel_timer, use gptd->base instead if it is not null.
149 virtual bool on_timeout(GEV_PER_TIMER_DATA *gptd) = 0;
150 virtual void cleanup(bool terminal);
151 void close(bool terminal);
152
153 protected:
154 GEV_PER_HANDLE_DATA *m_gphd = nullptr;
155 GEV_PER_TIMER_DATA *m_gptd = nullptr;
156 IEventBase *m_base = nullptr;
157 // us so instead of m_gphd,
158 // as the later one may destroyed during using…
159 SOCKET m_so;
160 };
161
162 // a common handler to process json protocol.
163 class GJsonEventHandler : public GEventHandler
164 {
165 public:
166 //virtual void on_read();
167 virtual void arg(void *param);
168 virtual void reset(GEV_PER_HANDLE_DATA *gphd, GEV_PER_TIMER_DATA *gptd, IEventBase *base);
169 virtual bool on_read(GEV_PER_IO_DATA *gpid);
170 virtual void on_read_msg(Json::Value const& root) = 0;
171 virtual bool on_timeout(GEV_PER_TIMER_DATA *gptd);
172 virtual void cleanup(bool terminal);
173
174 protected:
175 // protect m_stub to prevent multi-entry
176 #ifdef HAS_ET
177 std::mutex m_mutex;
178 #endif
179
180 std::string m_stub;
181 };
複製代碼
這裏主要有兩個類，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
複製代碼
1 #pragma once
2
3
4 #include “EventBase.h”
5 #include
6
7 #define GEV_RECONNECT_TIMEOUT 2 // seconds
8 #define GEV_MAX_RECONNECT_TIMEOUT 256 // seconds
9
10 class GEventBaseWithAutoReconnect : public GEventBase
11 {
12 public:
13 GEventBaseWithAutoReconnect(int reconn_min = GEV_RECONNECT_TIMEOUT, int reconn_max = GEV_MAX_RECONNECT_TIMEOUT);
14 ~GEventBaseWithAutoReconnect();
15
16 bool do_connect(unsigned short port, void arg);
17 GEventHandler connector();
18
19 protected:
20 virtual void on_error(GEventHandler *h);
21 virtual bool on_timeout(GEV_PER_TIMER_DATA gptd);
22
23 virtual void on_connect_break();
24 virtual bool on_connected(GEventHandler app);
25
26 protected:
27 void do_reconnect(void arg);
28
29 protected:
30 unsigned short m_port;
31 GEventHandler m_app;
32 GEventHandler m_htimer;
33 void m_timer;
34 int m_reconn_min;
35 int m_reconn_max;
36 int m_reconn_curr;
37 };
複製代碼
其實比較簡單，只比 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 按功用拆分了代碼模塊，你只需求選自己依賴的部分即可，不過我還沒有試過）。