封装的EPOLL 模型

1. #pragmaonce
2. #include<errno.h>
3. #include<sys/epoll.h>
4. #include<sys/types.h>
5. #include<sys/socket.h>
6. #include<fcntl.h>
7. #include<unistd.h>
8. #include<string.h>
9. #include"log.h"
11. #ifndefEPOLL_SIZE
12. #defineEPOLL_SIZE4096
13. #defineEPOLL_CONTEXT_SIZE(4096+256)
14. #endif
16. typedefvoid*EPollerContext;
17. classEpoller
18. {
19. public:
20. Epoller(){}
21. virtual~Epoller(){}
22. boolcreate()
23. {
24. memset(_contexts,0,sizeof(_contexts));
25. _handle=epoll_create(EPOLL_SIZE);
26. if(_handle==-1)
27. {
28. glog.log(__FUNCTION__,"Epollcreateerror,errnois%d",errno);
29. returnfalse;
30. }
31. else
32. returntrue;
33. }
34. voidhandle_events()
35. {
36. for(inti=0;i<_lastntfd;i++)
37. {
38. on_event(_events[i].data.fd,_events[i].events);
39. }
40. }
41. intget_online_users()
42. {
43. intresult=0;
44. for(inti=0;i<EPOLL_CONTEXT_SIZE;i++)
45. {
46. if(_contexts[i]!=0)
47. result++;
48. }
49. returnresult;
50. }
51. public:
52. booladd(intfd,unsignedintevents)
53. {
54. epoll_eventpolevt;
55. polevt.events=events;
56. polevt.data.fd=fd;
57. returnctl(EPOLL_CTL_ADD,fd,polevt)==0;
58. }
59. booldel(intfd,unsignedintevents)
60. {
61. epoll_eventpolevt;
62. polevt.events=events;
63. polevt.data.fd=fd;
64. returnctl(EPOLL_CTL_DEL,fd,polevt)==0;
65. }
66. boolmodify(intfd,unsignedintevents)
67. {
68. epoll_eventpolevt;
69. polevt.events=events;
70. polevt.data.fd=fd;
71. returnctl(EPOLL_CTL_MOD,fd,polevt)==0;
72. }
73. intpoll(inttimeout=5000)
74. {
75. _lastntfd=epoll_wait(_handle,_events,EPOLL_SIZE,timeout);
76. return_lastntfd;
77. }
78. protected:
79. intctl(intop,intfd,structepoll_event&event)
80. {
81. intret=epoll_ctl(_handle,op,fd,&event);
82. if(ret!=0)
83. {
84. glog.log(__FUNCTION__,"epoll_ctlfail,opis%d,fdis%d,errnois%d",op,fd,errno);
85. }
86. returnret;
87. }
88. protected:
89. staticboolsetnonblocking(intsock)
90. {
91. intopts;
92. opts=fcntl(sock,F_GETFL);
93. if(opts<0)
94. opts=O_NONBLOCK;
95. else
96. opts=opts|O_NONBLOCK;
97. if(fcntl(sock,F_SETFL,opts)<0)
98. {
99. glog.log(__FUNCTION__,"setnoblockerror");
100. returnfalse;
101. }
102. else
103. returntrue;
104. }
106. staticboolsetreuseport(intsock)
107. {
108. inton=1;
109. intret=setsockopt(sock,SOL_SOCKET,SO_REUSEADDR,(void*)&on,sizeof(int));
110. returnret!=-1;
111. }
115. protected:
116. virtualvoidon_event(intfd,intevents){}
117. private:
118. int_handle;
119. epoll_event_events[EPOLL_SIZE];
120. int_lastntfd;
121. protected:
122. EPollerContext_contexts[EPOLL_CONTEXT_SIZE];
123. EPollerContextget_context(intvalue)
124. {
125. return_contexts[value];
126. }
127. boolset_context(intvalue,EPollerContextcontext)
128. {
129. _contexts[value]=context;
130. }
131. };
140. classExampleServer:publicEpoller
141. {
142. public:
143. boolinit();
144. voidfini();
145. voidcheck_timeout();
146. protected:
147. voidon_event(intfd,intevents);
148. private:
149. voidadd_newsock(intsockvalue);
150. voidremove_sock(intsockvalue);
151. private:
152. int_listen_handler;
153. };
159. #include<sys/types.h>
160. #include<sys/socket.h>
161. #include<netinet/in.h>
162. #include"server.h"
163. #include"clientmanager.h"
165. boolExampleServer::init()
166. {
167. this->create();
168. _listen_handler=socket(AF_INET,SOCK_STREAM,0);
169. setnonblocking(_listen_handler);
170. setreuseport(_listen_handler);
171. sockaddr_inserveraddr;
172. memset(&serveraddr,0,sizeof(serveraddr));
173. serveraddr.sin_family=AF_INET;
174. serveraddr.sin_addr.s_addr=htonl(INADDR_ANY);
175. serveraddr.sin_port=htons(ITEMLIST_SERVER_PORT);
176. bind(_listen_handler,(sockaddr*)&serveraddr,sizeof(serveraddr));
177. listen(_listen_handler,ITEMCOMMENT_SERVER_LISTEN_BACKLOG);
178. this->add(_listen_handler,EPOLLIN|EPOLLOUT);
179. this->set_context(_listen_handler,0);
180. }
182. voidExampleServer::fini()
183. {
184. close(_listen_handler);
185. }
187. voidExampleServer::add_newsock(intsockvalue)
188. {
189. if(sockvalue>EPOLL_CONTEXT_SIZE)
190. {
191. glog.log(__FUNCTION__,"newsockis%d,>%d",sockvalue,EPOLL_CONTEXT_SIZE);
192. close(sockvalue);
193. return;
194. }
196. ClientSession*newsession=gClientManager.alloc_client_session(sockvalue);
197. if(newsession==NULL)
198. {
199. close(sockvalue);
200. return;
201. }
202. if(add(sockvalue,EPOLLIN|EPOLLOUT))
203. {
204. this->set_context(sockvalue,newsession);
205. }
206. else
207. {
208. gClientManager.release_client(newsession);
209. close(sockvalue);
210. }
211. }
213. voidExampleServer::remove_sock(intsockvalue)
214. {
215. this->del(sockvalue,0);
216. close(sockvalue);
217. ClientSession*client=(ClientSession*)this->get_context(sockvalue);
218. if(client)
219. {
220. gClientManager.release_client(client);
221. }
222. this->set_context(sockvalue,0);
223. }
225. voidExampleServer::on_event(intfd,intevents)
226. {
227. if(fd==_listen_handler)
228. {
229. sockaddr_insa;
230. memset(&sa,0,sizeof(sa));
231. socklen_tsalen=sizeof(sa);
232. intnewsock=accept(_listen_handler,(sockaddr*)&sa,&salen);
233. if(newsock>0)
234. {
235. add_newsock(newsock);
236. }
237. }
238. else
239. {
240. ClientSession*client=(ClientSession*)this->get_context(fd);
241. if(client!=NULL)
242. {
243. intnewevents=client->handle_events(fd,events);
244. if(newevents==0)
245. {
246. remove_sock(fd);
247. }
248. else
249. this->modify(fd,newevents);
250. }
251. }
252. }
255. voidExampleServer::check_timeout()
256. {
257. unsignedintcurtime=time(NULL);
258. for(inti=0;i<EPOLL_SIZE+256;i++)
259. {
260. ClientSession*client=(ClientSession*)this->get_context(i);
261. if(client!=NULL)
262. {
263. if(curtime-client->get_last_io_time()>ITEMINDEX_SERVER_MAX_TIMEOUT)
264. {
265. remove_sock(i);
266. }
267. }
268. }
269. }