nginx 代码分析listen 和request请求的流程

listen 针对于server的端口进行监听，server的配置可以比较复杂如：

server {
        listen       192.168.8.81:80;
        server_name  vae.test1.com *.test1.com;<!--hosts文件配置的地址-->
        index index.html;
        location /test1 {
           root /usr/local/nginx/html/;
        }
    }
    server {
        listen       127.0.0.1:80;
        server_name  vae.test1.com *.test1.com;<!--hosts文件配置的地址-->
        index index.html;
        location /test1 {
           root /usr/local/nginx/html/;
        }
    }

    server {
        listen       80;
        server_name  vae.test1.com;<!--hosts文件配置的地址-->
        index index.html;
        location /test1 {
           root /usr/local/nginx/html/;
        }
    }
server {
        listen       80;
        server_name  vae.test2.com;
        index index.html;
        location /test2 {
            root /usr/local/nginx/html/;
        }
    }
server {
        listen       8081;
        server_name  vae.test3.com;
        index index.html;
        location /test3 {
            root /usr/local/nginx/html/;
        }
    }

//完成之后需要重新启动下nginx命令：nginx -s reload，每次修改nginx.conf文件都需要重启

host配置:

#   127.0.0.1       localhost
#   ::1             localhost
192.168.8.81 vae.test1.com
192.168.8.81 vae.test2.com
192.168.8.81 vae.test3.com

ngx_http_add_listen 函数将解析http中的server的地址和端口，以port为粒度，添加addr（即1.1.1.1:80、2.2.2.2:80和80，会放在相同的cmcf->port[i]中）。
时序图和数据结构关系图：

那么在cmcf中的存储例子：

然后，就是在ngx_http_optimize_servers 中优化后加入cf->cycle->listening中(待完善)

接着在ngx_init_cycle –> ngx_open_listening_sockets中打开和监听所有的端口创建socket

在启动过程中的 ngx_worker_process_init中调用ngx_modules[event]->init_process(cycle) 初始化connections 并设置事件的回调 ，以ngx_epoll_moudle为例：

• ngx_event_process_init中 listen流程

/* 初始化用来管理所有定时器的红黑树,用于事件的处理轮询 */
if (ngx_event_timer_init(cycle->log) == NGX_ERROR) {
    return NGX_ERROR;
 }
 ....
 //分配和初始化cycle->connections，设置每个c的读写事件event
cycle->connections = ngx_alloc(sizeof(ngx_connection_t) * cycle->connection_n, cycle->log);
c = cycle->connections;
cycle->read_events = ngx_alloc(sizeof(ngx_event_t) * cycle->connection_n,cycle->log);
cycle->write_events = ngx_alloc(sizeof(ngx_event_t) * cycle->connection_n,cycle->log);
do {
     i--;
     c[i].data = next;
     c[i].read = &cycle->read_events[i]; //关联c[i]和rev wev
     c[i].write = &cycle->write_events[i];
     c[i].fd = (ngx_socket_t) -1;
     next = &c[i];
 } while (i);
 //针对监听的每个端口，分配connecting，并设置回调函数，加入到epoll池中
 //c = ngx_cycle->free_connections;
 ls = cycle->listening.elts;
    for (i = 0; i < cycle->listening.nelts; i++) {
        c = ngx_get_connection(ls[i].fd, cycle->log);
        ....
        rev->handler = ngx_event_accept;
        if (ngx_add_event(rev, NGX_READ_EVENT, 0) == NGX_ERROR) {
            return NGX_ERROR;
        }
    }

• ngx_event_accept请求的处理流程
  -这里涉及到ngx_use_accept_mutex的问题，用于解决多进程之间对请求的均衡处理(后续理解)

//epoll 中接收到请求后的回调，建立socket连接
void ngx_event_accept(ngx_event_t *ev)
{
    lc = ev->data;
    ls = lc->listening;
    s = accept(lc->fd, (struct sockaddr *) sa, &socklen);
    if (ngx_use_accept_mutex) {//进程竞争锁
        if (ngx_accept_mutex_held) {
            ngx_shmtx_unlock(&ngx_accept_mutex);
            ngx_accept_mutex_held = 0;
            }
            ngx_accept_disabled = 1;
    } else {
        ngx_add_timer(ev, ecf->accept_mutex_delay);
    }
    c = ngx_get_connection(s, ev->log);
}
//加入到epoll中等待read事件
 if (ngx_add_conn && (ngx_event_flags & NGX_USE_EPOLL_EVENT) == 0) {
        if (ngx_add_conn(c) == NGX_ERROR) {
            ngx_close_accepted_connection(c);
             return;
        }
 }
 //在ngx_http_add_listening时ls->handler = ngx_http_init_connection;设置回调
 ls->handler(c);//初始化这个对话connection

void ngx_http_init_connection(ngx_connection_t *c)
{//初始化一个request的connection
    //设置这个listen的addr_conf和conf_ctx，当数据可读时候用于解析
    hc = ngx_pcalloc(c->pool, sizeof(ngx_http_connection_t));
    if (hc == NULL) {
        ngx_http_close_connection(c);
        return;
    }
    c->data = hc;
    ....
    rev = c->read;//初始化read的epoll毁掉函数
    rev->handler = ngx_http_wait_request_handler;
    c->write->handler = ngx_http_empty_handler;
    //设置这个链接的超时timer
    ngx_add_timer(rev, c->listening->post_accept_timeout);
}

具体的时序图：

• ngx_http_wait_request_handler

当epoll中此connection可读，调用ngx_http_wait_request_handler(ngx_event_t *rev)
关于rev和connection中的关键数据data的关系

//request 中的main_conf/srv_conf/loc_conf
ngx_http_wait_request_handler(ngx_event_t *rev)
{
    n = c->recv(c, b->last, size);
    ....    
    c->data = ngx_http_create_request(c); //这里创建request
    {
        r->main_conf = hc->conf_ctx->main_conf;
        r->srv_conf = hc->conf_ctx->srv_conf;
        r->loc_conf = hc->conf_ctx->loc_conf;
    }

}

1. ngx_get_connection中 rev->data = c;

2. ngx_http_init_connection(*c) -> ngx_http_wait_request_handler(rev) -> c->data = ngx_http_create_request(rev)

//设置request 的connect到recv中：
ngx_http_process_request_line(ngx_event_t *rev)
{
    ngx_connection_t    *c;
    ngx_http_request_t  *r;

    c = rev->data; //ngx_get_connection中 rev->data = c;
    r = c->data;  
    //这里的data设置：ngx_http_init_connection(*c) -> ngx_http_wait_request_handler(rev) -> c->data = ngx_http_create_request(rev)
}

最后当请求request过来的时候就能够从rev中获取到request并且里面有相应的ngx_http_core_loc_conf_t

ngx_http_core_find_location 回顾上一篇文章中，根据url和ngx_http_core_loc_conf_t 的三叉排序树或者正则数组 来获取正确模块的loc_conf。

最后就可以调用模块的content_handler函数传入req->locf 完成整请求(待完善)

后续会针对初始化event 和 请求的流程写详细一点，这里只是从listen出发后续展开。