基于事件的开源网络库—libevent：应用实例

（接上一篇，本文给出具体应用的实例）

七、应用实例

本文例子不加修改在windows下运行（须定义宏WIN32，链接ws2_32.lib，libevent_core.lib），稍加修改（例如去掉windows所特有的socket初始化）可运行于Linux。

1.   最简单的例子，定时器

该例子创建了一个event_base，在此base上，增加了两个event，也就是设置了两个定时器，主要用来测试事件处理是否是多线程（结论是单线程）。这个例子也同时试验了给事件函数传入自定义参数的情况（例子中是一个整数）。

在main()函数中调用testlibevent_timer()即可运行该例子。

#include <stdio.h>
#include <time.h>

#include "libevent\event.h"
#include "libevent_timer.h"

#include "libevent\event_struct.h"
#include "libevent\util.h"


struct timeval lasttime;
typedef struct
{
	struct event *pevent;
	void *otherargs;
} event_arg_t;

void timeout_cb1(evutil_socket_t fd, short event, void *arg)
{
	struct timeval newtime, difference;
	event_arg_t *parg = (event_arg_t*)arg;
	struct event *timeout_ev = parg->pevent;
	int handle = *(int *)parg->otherargs;
	double elapsed;

	evutil_gettimeofday(&newtime, NULL);
	evutil_timersub(&newtime, &lasttime, &difference);
	elapsed = difference.tv_sec + (difference.tv_usec / 1.0e6);

	printf("timeout called at %d: %.3f s elapsed event=%d arg.handle=%d.\n",    (int)newtime.tv_sec, elapsed, event, handle);

//看看如果在一个事件处理中延时会出现什么情况
//Sleep(6000);
} 
void timeout_cb2(evutil_socket_t fd, short event, void *arg)
{
	struct timeval newtime, difference;
	event_arg_t *parg = (event_arg_t*)arg;
	struct event *timeout_ev = parg->pevent;
	int handle = *(int *)parg->otherargs;
	double elapsed;

	evutil_gettimeofday(&newtime, NULL);
	evutil_timersub(&newtime, &lasttime, &difference);
	elapsed = difference.tv_sec + (difference.tv_usec / 1.0e6);

	printf("timeout called at %d: %.3f s elapsed event=%d arg.handle=%d.\n",    (int)newtime.tv_sec, elapsed, event, handle);

} 

int testlibevent_timer(void)
{  
	event_arg_t timeout_arg1,timeout_arg2;
	struct event timeout_ev1,timeout_ev2 ;
	struct timeval tv;
	struct event_base *base;
	int flags;
	int handle1 = 2;
	int handle2 = 3;
	timeout_arg1.pevent = &timeout_ev1;
	timeout_arg1.otherargs = (void *)&handle1;
	timeout_arg2.pevent = &timeout_ev2;
	timeout_arg2.otherargs = (void *)&handle2;


	WORD wVersionRequested;
	WSADATA wsaData;
	int	err;

	wVersionRequested = MAKEWORD(2, 2);

	err = WSAStartup(wVersionRequested, &wsaData);

	flags = EV_PERSIST;     //	EV_PERSIST or 0

	/* Initalize the event library */
	base = event_base_new();

	/* Initalize one event */
	event_assign(&timeout_ev1, base, -1, flags, timeout_cb1, (void*) &timeout_arg1);
	event_assign(&timeout_ev2, base, -1, flags, timeout_cb2, (void*) &timeout_arg2);

	evutil_timerclear(&tv);
	tv.tv_sec = handle1;
	event_add(&timeout_ev1, &tv);
	tv.tv_sec = handle2;
	event_add(&timeout_ev2, &tv);

	evutil_gettimeofday(&lasttime, NULL);

	event_base_dispatch(base);

	return (0);
}  

这个例子比较简单，监视的句柄为-1，实际上不算是事件发生了，而是每次发生超时，调用了事件处理函数。

2.监听服务器的例子

这个例子创建一个监听某端口的服务器，采用事件的方式来处理请求。

#include <stdio.h>
#include <time.h>

#include "libevent\event.h"

#include "libevent\event_struct.h"
#include "libevent\buffer.h"
#include "libevent\bufferevent.h"
#include "libevent\listener.h"
#include "libevent\util.h"



void client_process(evutil_socket_t fd)
{
    //可以创建线程，自己编写read,recv,需要注意的是此时所有的socket操作都是非阻塞的。
	//
    evutil_closesocket(fd);
}


void echo_read_cb(struct bufferevent *bev, void *ctx)
{
        /* This callback is invoked when there is data to read on bev. */
        struct evbuffer *input = bufferevent_get_input(bev);
        struct evbuffer *output = bufferevent_get_output(bev);

        /* Copy all the data from the input buffer to the output buffer. */
        evbuffer_add_buffer(output, input);
}

void echo_event_cb(struct bufferevent *bev, short events, void *ctx)
{
        if (events & BEV_EVENT_ERROR)
                perror("Error from bufferevent");
        if (events & (BEV_EVENT_EOF | BEV_EVENT_ERROR)) {
                bufferevent_free(bev);
        }
}


void listener_cb(struct evconnlistener *listener, evutil_socket_t fd,  struct sockaddr *sa, int socklen, void *arg)
{
	
	//方法一：采用libevent中的buffer系列方法
	{
        struct event_base *base = evconnlistener_get_base(listener);
        struct bufferevent *bev = bufferevent_socket_new( base, fd, BEV_OPT_CLOSE_ON_FREE);

        bufferevent_setcb(bev, echo_read_cb, NULL, echo_event_cb, NULL);

        bufferevent_enable(bev, EV_READ|EV_WRITE);
	}
	
	//方法二：自己处理recv,read	
//	{
//       client_process(fd);
//    }
}


void accept_interrupt(evutil_socket_t fd, short what, void *arg)
{
    char timestr[60];
	get_time_string(timestr);
	printf("\n%s:accept_timeout.",timestr);

	event_t *parg = (event_t*)arg;
	struct event_base *base = event_get_base(&parg->eventbody);
	int handle = *(int *)parg->parg;
	if(handle == 3)
	{
        event_base_loopexit(base, NULL);
	}
}

int socket_server_event_test(void)
{
  	WSADATA  Ws;
	//Init Windows Socket
	if ( WSAStartup(MAKEWORD(2,2), &Ws) != 0 )
	{
		return -1;
	}
    

	int port = 2200;
    int max_conn = 10;       //backlog
	struct event_base *base;
	struct evconnlistener *listener;

	struct sockaddr_in sin;
	memset(&sin, 0, sizeof(sin));
	sin.sin_family = AF_INET;
	sin.sin_port = htons(port);



	// Initalize the event library 
	base = event_base_new();
	if (!base) 	return -2;

	listener = evconnlistener_new_bind(base, listener_cb, (void *)base,
	    LEV_OPT_REUSEABLE|LEV_OPT_CLOSE_ON_FREE, max_conn,
	    (struct sockaddr*)&sin,
	    sizeof(sin));
    

	event_t interrupt_ev;
	int handle = 3;
	struct timeval tv;
	interrupt_ev.parg = &handle;

	event_assign(&interrupt_ev.eventbody, base, -1, EV_PERSIST, accept_interrupt, (void*) &interrupt_ev);
	evutil_timerclear(&tv);
	tv.tv_sec = 40;
	event_add(&interrupt_ev.eventbody, &tv);


	event_base_dispatch(base);

	evconnlistener_free(listener);
	event_base_free(base);

WSACleanup();
    return 0;
}

上面的例子中，base需要监视两个事件，listening事件和定时器事件，设置定时器事件的目的是使该处理线程能有“机会”处理一下非listen事情，例如接到退出命令，停止listening等。接收到外部连接后，可以有两种办法：一是采用libevent的buffer系列方法读取端口，二是自己处理读写（可采用多线程）。

八、探究libevent的运行机制

研究libevent的运行机制，已超出本文范围。采用编译好的lib库的好处在于不必考虑其内部的运行，我们只要包含.h文件即可。libevent的源文件比较零散，作者在windows平台上，将它们集合在一起（一个目录下），修改了其引用路径，可以源代码级包含在项目中，这样可以设置断点来观察libevent的运行。有兴趣的同行可以从 这里下载试试（其中只包含了libevent_core.lib的内容）。