nginx事件模块之客户端连接与超时管理

        上一篇文章分析了nginx是如何管理监听事件，并把监听事件注册到epoll事件管理器中。接下来在这基础上分析当有客户端连接请求到来时，nginx是如何与客户端建立tcp连接，以及连接建立后又是如何管理超时事件。

一、连接事件管理

        在函数ngx_event_process_init中，会设置读事件的回调为ngx_event_accept。 这样设置后，在nginx服务器监听到来自客户端的连接请求后，该回调会被触发，用来与客户端建立tcp连接。连接建立后，就可以正常与客户端进行数据交互。

//ngx_event_core_module模块的init_process方法。在函数ngx_worker_process_init中被调用
static ngx_int_t ngx_event_process_init(ngx_cycle_t *cycle)
{
//对于每一个监听端口，从连接池中取出一个连接对象(也将从读时间，写事件池取出对象，
//使得连接，读、写保持一一对应关系),负责监听来自客户端的连接
ls = cycle->listening.elts;
for (i = 0; i < cycle->listening.nelts; i++)
{
c = ngx_get_connection(ls[i].fd, cycle->log);
//建立连接对象与监听对象的关系
c->listening = &ls[i];
//建立监听对象与连接对象的关系
ls[i].connection = c;
rev = c->read;

//设置连接回调，当有客户端连接时，将触发回调
rev->handler = ngx_event_accept;

//如果work进程之间没有使用枷锁，则把读事件加入epoll中
//此时写事件的回调为NULL，因为在ngx_get_connection函数中会把整个结构进行清0操作
if (ngx_add_event(rev, NGX_READ_EVENT, 0) == NGX_ERROR)
{
return NGX_ERROR;
}
}

        ngx_event_accept用来接收来自客户端的连接请求。tcp建立后，从连接池中获取一个新连接对象(同时获取到读、写事件)， 并把读事件加入到epoll中。这个新连接对象与监听对象作用是不同的。 监听对象注意用来监听来自客户端的连接，是还没有与客户端建立连接前被调用。而这个新连接对象是在tcp连接后被调用，用来与客户端进行数据读写。

//客户端请求连接回调
void ngx_event_accept(ngx_event_t *ev)
{
do
{
//接收客户端连接
s = accept(lc->fd, (struct sockaddr *) sa, &socklen);

//work进程之间赋值均衡，但一个work进程超过每一个进程的最大连接数的7/8时，
//则该work进程不在监听来自客户端的连接请求。但已经建立tcp连接的客户端不收影响，正常进行数据读写
ngx_accept_disabled = ngx_cycle->connection_n / 8
- ngx_cycle->free_connection_n;

//获取一个空闲连接对象(同时也获取到读，写事件)
c = ngx_get_connection(s, ev->log);

//给新连接对象赋值
c->pool = ngx_create_pool(ls->pool_size, ev->log);
c->sockaddr = ngx_palloc(c->pool, socklen);
ngx_memcpy(c->sockaddr, sa, socklen);

//设置从内核读取数据，写入数据的的公共方法。这些方法实际上就是ngx_os_io结构的各个成员
//这些方法为什么不设置在事件对象上，而是设置在连接对象。因为这对读写事件而言，这些方法是公共的。
//连接对象里面包含了读写事件对象的引用关系，如果设置在相应的读事件，或者写事件上，则每个事件都需要设置一次
//而在连接对象上只需要设置一次
c->recv = ngx_recv;
c->send = ngx_send;
c->recv_chain = ngx_recv_chain;
c->send_chain = ngx_send_chain;

//连接对象里面的监听指针指向ls，但ls并没有把连接指向当前已经调用accept的这个连接，
//而是指向监听连接对象
c->listening = ls;

//调用监听对象的方法, 将读事件写入到epoll
//考虑下为什么要把这个回调设置在监听对象上，而不是连接对象上。
//因为如果有5个客户端连接上同一个监听socket, 则会创建5个连接对象。而每一个连接对象都需要设置
//这个回调，占用4字节指针空间，浪费内存资源。而如果回调设置在监听对象上，则只需要设置一次回调就可以了。
ls->handler(c);		//ngx_http_init_connection

} while (ev->available);
}

        在函数中会调用ngx_listening_s对象的handler方法。这个方法其实就是ngx_http_init_connection，在ngx_http_add_listening函数中设置。

ngx_http_init_listening
   ---> ngx_http_add_listening

           --->

//创建一个ngx_listening_t对象，并给对象的成员赋值。例如设置监听回调
ngx_listening_t * ngx_http_add_listening(ngx_conf_t *cf, ngx_http_conf_addr_t *addr)
{
//创建一个ngx_listening_t对象
ls = ngx_create_listening(cf, &addr->opt.u.sockaddr, addr->opt.socklen);

//监听回调
ls->handler = ngx_http_init_connection;
}

        ngx_http_init_connection是用来为新建立的客户端连接注册读事件回调ngx_http_init_request、写事件回调ngx_http_empty_handler、同时将注册读事件的超时事件到红黑树实现的定时器中。最终将读事件放入到epoll中。这些操作执行之后，就可以接收来自客户端的数据了。

//在收到客户端连接时，ngx_event_accept函数中会调用ngx_listening_t的handler，也就是本函数
//功能:注册客户端的读写事件回调
void ngx_http_init_connection(ngx_connection_t *c)
{
rev = c->read;
//读事件回调
rev->handler = ngx_http_init_request;

//该写回调没有做任何事件，因为这个阶段还不需要向客户端写入任何数据
c->write->handler = ngx_http_empty_handler;

//将读事件插入到红黑树中，用于管理超时事件，post_accept_timeout超时事件
//为nginx.conf中的client_header_timeout选项
ngx_add_timer(rev, c->listening->post_accept_timeout);

//将读事件注册到epoll中，此时并没有把写事件注册到epoll中，因为现在还不需要向客户端发送任何数据，所以写事件并不需要注册
ngx_handle_read_event(rev, 0);
}

        nginx服务器处理完客户端的连接请求后，又回到了work进程的事件循环中。监听新建立的对象，等待客户端发来的数据，与客户端进行数据交互。

//work进程的事件循环
static void ngx_worker_process_cycle(ngx_cycle_t *cycle, void *data)
{
for ( ;; )
{
ngx_process_events_and_timers(cycle);
}
}

二、超时事件管理

        nginx服务器在监听到来自客户端的连接请求后，会与客户端建立一个tcp连接，并为这个新连接注册读写事件，并将读事件的超时事件加入到红黑树实现的定时器中。

从上面的ngx_http_init_connection函数中就可以看出这些操作，并把读事件添加到了红黑树实现的定时器中。

//在收到客户端连接时，ngx_event_accept函数中会调用ngx_listening_t的handler，也就是本函数
//功能:注册客户端的读写事件回调
void ngx_http_init_connection(ngx_connection_t *c)
{
rev = c->read;
//读事件回调
rev->handler = ngx_http_init_request;

//该写回调没有做任何事件，因为这个阶段还不需要向客户端写入任何数据
c->write->handler = ngx_http_empty_handler;

//将读事件插入到红黑树中，用于管理超时事件，post_accept_timeout超时事件
//为nginx.conf中的client_header_timeout选项
ngx_add_timer(rev, c->listening->post_accept_timeout);

//将读事件注册到epoll中
ngx_handle_read_event(rev, 0);
}

        ngx_event_add_timer负责将事件注册到红黑树实现的定时器中。红黑树中的所有超时事件节点都是通过ngx_event_s对象的timer成员给串接起来。而定时器中每一个超时事件节点的key就是超时时间，记录该事件的超时时间。

//将定时事件添加到红黑树中，timer为超时时间
static ngx_inline void ngx_event_add_timer(ngx_event_t *ev, ngx_msec_t timer)
{
ngx_msec_t      key;
ngx_msec_int_t  diff;

key = ngx_current_msec + timer;

//已经将事件插入到红黑树种，则先删除之前的事件
if (ev->timer_set)
{
ngx_del_timer(ev);
}

//设置定时器的唯一id，也就是时间
ev->timer.key = key;

//插入到红黑树种
ngx_rbtree_insert(&ngx_event_timer_rbtree, &ev->timer);

//表示事件已经存在红黑树中了
ev->timer_set = 1;
}

        将读事件加入到红黑树定时器后，接下来work进程进入事件循环，阻塞在epoll_wait调用。那epoll_wait什么时候返回呢? 在接收到客户端的数据后，或者每个事件的定时时间到后，可以从epoll_wait返回。接下来看下如何设置epoll_wait的超时时间，使得定时时间到后，能及时从epoll_wait返回。

//work进程事件循环
void ngx_process_events_and_timers(ngx_cycle_t *cycle)
{
//在红黑树中查找所有事件的最小超时事件，返回值timer就是所有事件的最小超时时间
timer = ngx_event_find_timer();

//调用epoll_wait等待事件
(void) ngx_process_events(cycle, timer, flags);

//epoll_wait返回后，处理所有超时事件
ngx_event_expire_timers();
}

        红黑树是一颗二叉排序树，因此最小超时时间实际上就是左子树的最小值。因此可以看到ngx_event_find_timer函数的实现，就是在左子树种查找最小值。如不清楚红黑树的实现，则可以查看july大神的博客http://www.cnblogs.com/v-July-v/archive/2010/12/29/1983707.html

//返回红黑树中最小事件的超时事件;
//返回值:>0 表示还剩多长事件超时
//		 <=0 表示事件已经超时
ngx_msec_t ngx_event_find_timer(void)
{
ngx_msec_int_t      timer;
ngx_rbtree_node_t  *node, *root, *sentinel;

//红黑树为空，则返回-1表示事件已经超时
if (ngx_event_timer_rbtree.root == &ngx_event_timer_sentinel)
{
return NGX_TIMER_INFINITE;
}
root = ngx_event_timer_rbtree.root;
sentinel = ngx_event_timer_rbtree.sentinel;
//查找左字数
node = ngx_rbtree_min(root, sentinel);

//计算剩余超时时间
timer = (ngx_msec_int_t) node->key - (ngx_msec_int_t) ngx_current_msec;

return (ngx_msec_t) (timer > 0 ? timer : 0);
}

        而epoll_wait调用返回后，如果有事件超时了，那如何处理这些超时事件呢？ngx_event_expire_timers内部会遍历红黑树，查找所有已经超时的事件，并调用这些超时事件的处理回调。需要注意的是，函数也会从红黑树中删除这个超时事件，因此如果还需要管理这个超时事件，则需要重新把事件添加到红黑树实现的定时器中。

//调用红黑树中所有已经超时的事件回调，并把已经超时的事件从红黑树中删除
void ngx_event_expire_timers(void)
{
ngx_event_t        *ev;
ngx_rbtree_node_t  *node, *root, *sentinel;

sentinel = ngx_event_timer_rbtree.sentinel;
//遍历红黑树，查找超时事件
for ( ;; )
{
root = ngx_event_timer_rbtree.root;
//红黑树为空则返回
if (root == sentinel)
{
return;
}

//取出红黑树中时间最小的节点
node = ngx_rbtree_min(root, sentinel);

/* node->key <= ngx_current_time */
//发生超时
if ((ngx_msec_int_t) node->key - (ngx_msec_int_t) ngx_current_msec <= 0)
{
ev = (ngx_event_t *) ((char *) node - offsetof(ngx_event_t, timer));

//从红黑树中删除这个已经超时的定时器事件
ngx_rbtree_delete(&ngx_event_timer_rbtree, &ev->timer);

//表示事件已经不存在定时器中了
ev->timer_set = 0;

//标示事件已经超时
ev->timedout = 1;

//调用事件回调
ev->handler(ev);

//直接处理下一个超时事件，前一个超时事件已经从红黑树中删除了
continue;
}

//没有事件超时则直接退出，因此最小时间都没有超时，那红黑树中其它时间也肯定没有超时
break;
}
}

        到此，超时事件的管理也分析完成了。