sevencat封装的Epoll模型

#pragma once
#include <errno.h>
#include <sys/epoll.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>
#include "log.h"

#ifndef EPOLL_SIZE
#define EPOLL_SIZE 4096
#define EPOLL_CONTEXT_SIZE (4096+256)
#endif

typedef void * EPollerContext;
class Epoller
{
public:
Epoller(){}
virtual ~Epoller(){}
bool create()
{
 memset(_contexts,0,sizeof(_contexts));
 _handle=epoll_create(EPOLL_SIZE);
 if(_handle==-1)
 {
  glog.log(__FUNCTION__,"Epoll create error,errno is %d",errno);
  return false;
 }
 else
  return true;
}
void handle_events()
{
 for(int i=0;i<_lastntfd;i++)
 {
  on_event(_events[i].data.fd,_events[i].events);
 }
}
int get_online_users()
{
 int result=0;
 for(int i=0;i<EPOLL_CONTEXT_SIZE;i++)
 {
  if(_contexts[i]!=0)
   result++;
 }
 return result;
}
public:
bool add(int fd,unsigned int events)
{
 epoll_event polevt;
 polevt.events=events;
 polevt.data.fd=fd;
 return ctl(EPOLL_CTL_ADD,fd,polevt)==0;
}
bool del(int fd,unsigned int events)
{
 epoll_event polevt;
 polevt.events=events;
 polevt.data.fd=fd;
 return ctl(EPOLL_CTL_DEL,fd,polevt)==0;
}
bool modify(int fd,unsigned int events)
{
 epoll_event polevt;
 polevt.events=events;
 polevt.data.fd=fd;
 return ctl(EPOLL_CTL_MOD,fd,polevt)==0;
}
int poll(int timeout=5000)
{
 _lastntfd=epoll_wait(_handle,_events,EPOLL_SIZE,timeout);
 return _lastntfd;
}
protected:
int ctl(int op, int fd, struct epoll_event &event)
{
 int ret=epoll_ctl(_handle,op,fd,&event);
 if(ret!=0)
 {
  glog.log(__FUNCTION__,"epoll_ctl fail,op is %d,fd is %d,errno is %d",op,fd,errno);
 }
 return ret;
}
protected:
static bool setnonblocking(int sock)
{
 int opts;
 opts=fcntl(sock,F_GETFL);
 if(opts<0)
  opts=O_NONBLOCK;
 else
  opts = opts|O_NONBLOCK;
 if(fcntl(sock,F_SETFL,opts)<0)
 {
  glog.log(__FUNCTION__,"setnoblock error");
  return false;
 }
 else
  return true;
}

static bool setreuseport(int sock)
{
 int on=1;
 int ret=setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (void *)&on, sizeof(int));
 return ret!=-1;
}



protected:
virtual void on_event(int fd,int events){}
private:
int _handle;
epoll_event _events[EPOLL_SIZE];
int _lastntfd;
protected:
EPollerContext _contexts[EPOLL_CONTEXT_SIZE];
EPollerContext get_context(int value)
{
 return _contexts[value];
}
bool set_context(int value,EPollerContext context)
{
 _contexts[value]=context;
}
};








class ExampleServer : public Epoller
{
public:
bool init();
void fini();
void check_timeout();
protected:
void on_event(int fd,int events);
private:
void add_newsock(int sockvalue);
void remove_sock(int sockvalue);
private:
int _listen_handler;
};





#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include "server.h"
#include "clientmanager.h"

bool ExampleServer::init()
{
this->create();
_listen_handler=socket(AF_INET,SOCK_STREAM,0);
setnonblocking(_listen_handler);
setreuseport(_listen_handler);
sockaddr_in serveraddr;
memset(&serveraddr,0,sizeof(serveraddr));
serveraddr.sin_family = AF_INET;
serveraddr.sin_addr.s_addr=htonl(INADDR_ANY);
serveraddr.sin_port=htons(ITEMLIST_SERVER_PORT);
bind(_listen_handler,(sockaddr *)&serveraddr, sizeof(serveraddr));
listen(_listen_handler,ITEMCOMMENT_SERVER_LISTEN_BACKLOG);
this->add(_listen_handler,EPOLLIN|EPOLLOUT);
this->set_context(_listen_handler,0);
}

void ExampleServer::fini()
{
close(_listen_handler);
}

void ExampleServer::add_newsock(int sockvalue)
{
if(sockvalue>EPOLL_CONTEXT_SIZE)
{
 glog.log(__FUNCTION__,"newsock is %d,> %d",sockvalue,EPOLL_CONTEXT_SIZE);
 close(sockvalue);
 return;
}

ClientSession *newsession=gClientManager.alloc_client_session(sockvalue);
if(newsession==NULL)
{
 close(sockvalue);
 return;
}
if(add(sockvalue,EPOLLIN|EPOLLOUT))
{
 this->set_context(sockvalue,newsession);
}
else
{
 gClientManager.release_client(newsession);
 close(sockvalue);     
}
}

void ExampleServer::remove_sock(int sockvalue)
{
this->del(sockvalue,0);
close(sockvalue);
ClientSession *client=(ClientSession *)this->get_context(sockvalue);
if(client)
{
 gClientManager.release_client(client);
}
this->set_context(sockvalue,0);
}

void ExampleServer::on_event(int fd,int events)
{
if(fd==_listen_handler)
{
 sockaddr_in sa;
 memset(&sa,0,sizeof(sa));
 socklen_t salen=sizeof(sa);
 int newsock=accept(_listen_handler,(sockaddr *)&sa,&salen);
 if(newsock>0)
 {
  add_newsock(newsock);
 }
}
else
{
 ClientSession *client=(ClientSession *)this->get_context(fd);
 if(client!=NULL)
 {
  int newevents=client->handle_events(fd,events);
  if(newevents==0)
  {
   remove_sock(fd);
  }
  else
   this->modify(fd,newevents);
 }
}
}


void ExampleServer::check_timeout()
{
unsigned int curtime=time(NULL);
for(int i=0;i<EPOLL_SIZE+256;i++)
{
 ClientSession *client=(ClientSession *)this->get_context(i);
 if(client!=NULL)
 {
  if(curtime-client->get_last_io_time()>ITEMINDEX_SERVER_MAX_TIMEOUT)
  {
   remove_sock(i);
  }
 }
}
}