基于事件驱动网络服务器实现
socket 的事件类型有 读事件（socket链接也属于读事件）、写事件、socket 关闭事件
事件处理方式无非就是添加事件、删除事件、分发执行事件
大致逻辑就是：
事件驱动的网络实现逻辑
Loop:
EventOp->dispatch() // 由 select或epoll 进行事件监听
将监听的事件添加到事件列表里
for(ev : event_list):
if ev & ev_read && fd 是server 端
建立与客户端的链接，标识为读事件加入事件列表
if ev & ev_read:
read_msg();
if ev & ev_write:
send_msg()
if ev & ev_closed:
close_session()也可以将上面的逻辑放入多线程中，就是大家经常讲的基于事件高性能服务器的实现。还有一点需要注意，socket 一定是非阻塞的，否则循环会卡住。
可以参考libevent、redis的网络实现，逻辑就是上面的形式。
事件后端基本上都是利用select、epoll、kequeue实现
class EventOp
{
public:
virtual bool Init();
bool Dispatch();
virtual bool InitOp() = 0;
virtual bool AddEvent(socket_t fd, int mask) = 0; # mask 就是ev_read ev_write ev_closed
virtual bool DelEvent(socket_t fd, int mask) = 0;
virtual bool Dispatch(struct timeval* tv) = 0;
virtual bool Clear() = 0;
};
class SeEpoll : public EventOp
{
public:
SeEpoll();
~SeEpoll();
virtual bool InitOp();
virtual bool AddEvent(socket_t fd, int mask);
virtual bool DelEvent(socket_t fd, int mask);
virtual bool Dispatch(struct timeval* tv);
virtual bool Clear();
};
bool SeEpoll::InitOp()
{
#ifdef EVENT_HAVE_EPOLL_CREATE1
mEpollOp.epfd = epoll_create1(EPOLL_CLOEXEC);
#endif
if (mEpollOp.epfd == -1)
{
mEpollOp.epfd = epoll_create(1024);
Assert(mEpollOp.epfd != -1);
}
mEpollOp.events = new epoll_event[EPOLL_EVENT_NUM];
if (mEpollOp.events == nullptr)
{
return false;
}
return true;
}
bool SeEpoll::AddEvent(socket_t fd, int mask)
{
uint32_t events = 0;
if (mask & EV_READ)
{
events = EPOLLET | EPOLLONESHOT | EPOLLIN;
}
if (mask & EV_WRITE)
{
events = EPOLLET | EPOLLONESHOT | EPOLLOUT;
}
struct epoll_event ev = { 0 };
short op = 0;
auto it = mEvents.find(fd);
if (it == mEvents.end())
{
ev.data.fd = fd;
ev.events = events; // EPOLLET | EPOLLONESHOT | EPOLLIN | EPOLLOUT
mEvents.emplace(fd, ev);
op = EPOLL_CTL_ADD;
}
else
{
ev = it->second;
ev.events = events;
op = EPOLL_CTL_MOD;
}
if (epoll_ctl(mEpollOp.epfd, op, fd, &ev) == 0)
{
return true;
}
switch (op) {
case EPOLL_CTL_MOD:
if (errno == ENOENT) {
if (epoll_ctl(mEpollOp.epfd, EPOLL_CTL_ADD, fd, &ev) == -1) {
return false;
}
return true;
}
break;
case EPOLL_CTL_ADD:
if (errno == EEXIST) {
if (epoll_ctl(mEpollOp.epfd, EPOLL_CTL_MOD, fd, &ev) == -1) {
return false;
}
return true;
}
break;
case EPOLL_CTL_DEL:
if (errno == ENOENT || errno == EBADF || errno == EPERM) {
return true;
}
break;
default:
break;
}
return false;
}
bool SeEpoll::DelEvent(socket_t fd, int mask)
{
auto it = mEvents.find(fd);
if (it == mEvents.end())
{
return false;
}
if (epoll_ctl(mEpollOp.epfd, EPOLL_CTL_DEL, fd, nullptr) == 0)
{
return true;
}
return false;
}
bool SeEpoll::Dispatch(struct timeval* tv)
{
int ret, nEvents = 0;
ret = epoll_wait(mEpollOp.epfd, mEpollOp.events, EPOLL_EVENT_NUM,
tv ? (tv->tv_sec * 1000 + tv->tv_usec / 1000) : -1);
if (ret == -1)
{
if (SOCKET_ERR_RW_RETRIABLE(errno))
{
return true;
}
fprintf(stderr, "epoll_wait error %d:%s", errno, strerror(errno));
return false;
}
if (ret > 0)
{
nEvents = ret;
for (int i = 0; i < nEvents; i++)
{
struct epoll_event ev = mEpollOp.events[i];
int mask = 0;
if (ev.events & (EPOLLHUP | EPOLLERR))
{
mask = EV_READ | EV_WRITE;
}
else
{
if (ev.events & EPOLLIN)
{
mask |= EV_READ;
AddEvent(ev.data.fd, mask);
}
if (ev.events & EPOLLOUT)
{
mask |= EV_WRITE;
AddEvent(ev.data.fd, mask);
}
if (ev.events & EPOLLRDHUP)
{
mask |= EV_CLOSED;
DelEvent(ev.data.fd, EPOLLRDHUP);
}
}
if (mask == 0)
{
continue;
}
SetEvent(ev.data.fd, mask);
}
}
return true;
}
bool SeEpoll::Clear()
{
SocketCloseOnExec(mEpollOp.epfd);
mEpollOp.epfd = -1;
delete[] mEpollOp.events;
return true;
}