Nginx在7层负载交换、反向代理服务领域使用比较广泛。Nginx的结构也比较简单，除了底层几个核心的模块(如ngx_core_module，ngx_event_core_module，ngx_errlog_module等)之外，其它的主要是基于上述核心模块的http和mail的模块组，负责处理相关服务。而这些模块也可以在编译的时候被enable/disable，取决于对实际功能的需求。在这里，我来分析一下Nginx用的最多的功能，即处理http请求的工作流程。
在事件处理的分析中，提到过当有http请求过来时事件的触发和处理过程。我们知道，在一个子进程accept()请求之后，会调用ngx_http_init_connection()函数。这个函数会添加一个读事件，并设置其handler为ngx_http_init_request()。但是，对于http模块的载入以及初始化，却是要从http_block()开始。在父进程(master process)调用ngx_init_cycle()的时候，会调用一次ngx_conf_parse()函数(先不在这里分析)，这个时候(解析到了"http {...}" block)，ngx_http_module模块的set()函数即ngx_http_block()就被调用。
static char * ngx_http_block(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
{
/* the main http context */
//它里面只有三个成员：(void**)main_conf，(void**)srv_conf和(void**)loc_conf，注意它们是双层指针
//每个NGX_HTTP_MODULE模块都有一个main_conf[i]，srv_conf[i]和loc_conf[i]指向相应的上下文，但不是每个都会用到。
ctx = ngx_pcalloc(cf->pool, sizeof(ngx_http_conf_ctx_t));
*(ngx_http_conf_ctx_t **) conf = ctx;
/* 清点NGX_HTTP_MODULE类型模块个数并给每个模块设定索引(index) */
ngx_http_max_module = 0;
for (m = 0; ngx_modules[m]; m++) {
if (ngx_modules[m]->type != NGX_HTTP_MODULE) {
continue;
}
ngx_modules[m]->ctx_index = ngx_http_max_module++;
}
//main_conf在http{...}里面的所有上下文中都是一致的
//分配内存，个数为http模块的个数
ctx->main_conf = ngx_pcalloc(cf->pool, sizeof(void *) * ngx_http_max_module);
//用来合并server{...}里面的srv_conf
//分配内存，个数为http模块的个数
ctx->srv_conf = ngx_pcalloc(cf->pool, sizeof(void *) * ngx_http_max_module);
//用来合并 /loc {...} 里面的loc_conf
//分配内存，个数为http模块的个数
ctx->loc_conf = ngx_pcalloc(cf->pool, sizeof(void *) * ngx_http_max_module);
//如有定义的话，调用每个http模块里面的create_main_conf()，create_srv_conf()和create_loc_conf()
for (;;) {
//如果是NGX_HTTP_MODULE模块
module = ngx_modules[m]->ctx;//module的上下文，为ngx_http_module_t类型
mi = ngx_modules[m]->ctx_index;//在http模块组里的索引
//如有的话，就调用每个模块的下列函数，并存入ctx相应的索引位
//一般在 http {...}里面而不在 server {...}里面有命令的模块有create_main_conf()
//一般在 server {...}里面而不在 /loc {...}里面有命令的模块有create_srv_conf()
//一般在 /loc {...}里面有命令的模块有create_loc_conf()
ctx->main_conf[mi] = module->create_main_conf(cf);
ctx->srv_conf[mi] = module->create_srv_conf(cf);
ctx->loc_conf[mi] = module->create_loc_conf(cf);
}
pcf = *cf;
cf->ctx = ctx;//把ctx放入cf
for (;;) {
//调用每个NGX_HTTP_MODULE模块的preconfiguration()函数
//一般模块的preconfiguration()作用是添加一些模块要用的变量到ngx_http_core_main_conf_t的hash表variables_keys
module->preconfiguration(cf);
}
/* parse inside the http{} block */
cf->module_type = NGX_HTTP_MODULE;
cf->cmd_type = NGX_HTTP_MAIN_CONF;
rv = ngx_conf_parse(cf, NULL);
//获取ngx_http_core_module(定义一些http公用的命令和变量)的main_conf
cmcf = ctx->main_conf[ngx_http_core_module.ctx_index];
cscfp = cmcf->servers.elts;
for (;;) {
//调用每个NGX_HTTP_MODULE模块的init_main_conf()和ngx_http_merge_servers()
rv = module->init_main_conf(cf, ctx->main_conf[mi]);
rv = ngx_http_merge_servers(cf, cmcf, module, mi);
}
/* create location trees */
//给每个server创建location tree
for (s = 0; s < cmcf->servers.nelts; s++) {
clcf = cscfp[s]->ctx->loc_conf[ngx_http_core_module.ctx_index];
//location根据字母顺序排序
ngx_http_init_locations(cf, cscfp[s], clcf);
//建立静态location树(三叉树)
ngx_http_init_static_location_trees(cf, clcf);
}
//初始化几个phase的handler(分配内存)
if (ngx_http_init_phases(cf, cmcf) != NGX_OK) {
return NGX_CONF_ERROR;
}
//初始化header的hash table
if (ngx_http_init_headers_in_hash(cf, cmcf) != NGX_OK) {
return NGX_CONF_ERROR;
}
for (;;) {
//注册每个模块对应phase的处理函数
//这儿的处理函数是通用的(如http模块的所有location)
//特定location的处理函数在指令(directive)的set()里面设置
module->postconfiguration(cf);
}
//设置pre-defined variables的get_handler等，并放入hash table里
if (ngx_http_variables_init_vars(cf) != NGX_OK) {
return NGX_CONF_ERROR;
}
//注册各http模块phase的checker，并把postconfiguration注册的handler都放到cmcf的phase_engine，phase_engine把cheker和对应的handler一同放入数组，供之后处理phase的时候调用。
if (ngx_http_init_phase_handlers(cf, cmcf) != NGX_OK) {
return NGX_CONF_ERROR;
}
//把server_name储存在hash table里，最后给每个listening socket注册ls->handler=ngx_http_init_connection；
if (ngx_http_optimize_servers(cf, cmcf, cmcf->ports) != NGX_OK) {
return NGX_CONF_ERROR;
}
return NGX_CONF_OK;
}
===================================================================================
当nginx收到请求的时候，就会调用(1)ngx_http_init_request，开始了对请求的处理过程。
static void ngx_http_init_request(ngx_event_t *rev)
{
//获取event的connection
c = rev->data;
//如果事件超时
//...
hc = c->data;
//给这个ngx_http_connection_t类型的指针分配内存
//...
r = hc->request;
//创建(re-init)一个新的request
//...
c->data = r;
r->http_connection = hc;
c->sent = 0;
r->signature = NGX_HTTP_MODULE;
/* find the server configuration for the address:port */
port = c->listening->servers;//在http_block()的时候就已经设置完成
r->connection = c;
//如果有多个监听的addr
if (port->naddrs > 1) {
/*
* there are several addresses on this port and one of them
* is an "*:port" wildcard so getsockname() in ngx_http_server_addr()
* is required to determine a server address
*/
if (ngx_connection_local_sockaddr(c, NULL, 0) != NGX_OK) {
ngx_http_close_connection(c);
return;
}
switch (c->local_sockaddr->sa_family) {
default: /* AF_INET */
sin = (struct sockaddr_in *) c->local_sockaddr;
addr = port->addrs;
/* the last address is "*" */
for (i = 0; i < port->naddrs - 1; i++) {
if (addr[i].addr == sin->sin_addr.s_addr) {
break;
}
}
addr_conf = &addr[i].conf;
break;
}
} else {
switch (c->local_sockaddr->sa_family) {
default: /* AF_INET */
addr = port->addrs;
addr_conf = &addr[0].conf;
break;
}
}
r->virtual_names = addr_conf->virtual_names;
/* the default server configuration for the address:port */
cscf = addr_conf->core_srv_conf;
r->main_conf = cscf->ctx->main_conf;
r->srv_conf = cscf->ctx->srv_conf;
r->loc_conf = cscf->ctx->loc_conf;
//event的handler设为ngx_http_process_request_line
rev->handler = ngx_http_process_request_line;
//设置request的读事件
r->read_event_handler = ngx_http_block_reading;
clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);
c->log->file = clcf->error_log->file;
r->ctx = ngx_pcalloc(r->pool, sizeof(void *) * ngx_http_max_module);
cmcf = ngx_http_get_module_main_conf(r, ngx_http_core_module);
//分配内存给variables
r->variables = ngx_pcalloc(r->pool, cmcf->variables.nelts *
sizeof(ngx_http_variable_value_t));
c->single_connection = 1;
c->destroyed = 0;
//对r的其它的初始化
r->main = r;//主请求
r->method = NGX_HTTP_UNKNOWN;
r->headers_in.content_length_n = -1;
r->headers_in.keep_alive_n = -1;
r->headers_out.content_length_n = -1;
r->headers_out.last_modified_time = -1;
r->uri_changes = NGX_HTTP_MAX_URI_CHANGES + 1;
r->subrequests = NGX_HTTP_MAX_SUBREQUESTS + 1;
r->http_state = NGX_HTTP_READING_REQUEST_STATE;
ctx = c->log->data;
ctx->request = r;
ctx->current_request = r;
r->log_handler = ngx_http_log_error_handler;
rev->handler(rev); //ngx_http_process_request_line
}
下面，分别调用了下列函数，在这里不一一详细分析：
-->(2)ngx_http_process_request_line()//读取、解析请求行，并存入r的相应成员(如uri,args相关的重要指针)。
-->(3)ngx_http_process_request_headers()//把header line逐行解析并以key-value形式存入r。
-->(4)ngx_http_process_request()-->(5)ngx_http_handler()
-->(6)ngx_http_core_run_phases()
void ngx_http_core_run_phases(ngx_http_request_t *r)
{
cmcf = ngx_http_get_module_main_conf(r, ngx_http_core_module);
ph = cmcf->phase_engine.handlers;//拿到phase_engine里存放所有handler的数组
//如果不是内部定向(rewrite)的话，r->phase_handler = 0;
//每个phase的checker在ngx_http_init_phase_handlers设置
//每个phase的handler在ngx_http_init_phase_handlers设置
//ph(ngx_http_phase_handler_s类型)的顺序：越早在postconfiguration()时注册handler的模块，它的handler在ph里面就越靠后被调用。
while (ph[r->phase_handler].checker) {
//ngx_http_init_phase_handlers里面注册每个phase的checker和handler
rc = ph[r->phase_handler].checker(r, &ph[r->phase_handler]);
if (rc == NGX_OK) {
return;
}
}
}
关于ngx_http_core_main_conf_t，它里面有两个成员，phase_engine和phases。其中phases是一个存放所有模块的在postconfiguration()函数里面注册的相关phase的handler。比如，ngx_http_index_module里面，就push了一个NGX_HTTP_CONTENT_PHASE的handler：ngx_http_index_handler。这个handler就被存放在ngx_http_core_main_conf_t的phases[NGX_HTTP_CONTENT_PHASE]这个数组里面。而phase_engine里面的handlers(ngx_http_phase_handler_s类型)则是一个checker和handler的函数对，next指向下一个phase在phase_engine里面的index。
比如说，最基本的一个处理过程：NGX_HTTP_FIND_CONFIG_PHASE --> NGX_HTTP_PREACCESS_PHASE --> NGX_HTTP_ACCESS_PHASE --> NGX_HTTP_CONTENT_PHASE。被调用的函数是：
//NGX_HTTP_FIND_CONFIG_PHASE的checker
ngx_http_core_find_config_phase()
{
//调用ngx_http_core_find_static_location()，比较r的uri和config tree的名字，找到合适的/location，并更新r->loc_conf
ngx_http_core_find_location();
//基于r->loc_conf，更新r的相应成员变量
//其中如果有一些location调用了某些模块的命令设置了特定的clcf->handler，r->content_handler = clcf->handler。在ngx_http_core_content_phase()里面就会被调用。
ngx_http_update_location_config();
//goto next handler即next phase
r->phase_handler++;
}
NGX_HTTP_PREACCESS_PHASE的checker是ngx_http_core_generic_phase()，即调用ph->handler(r)。在默认的模块配置里，NGX_HTTP_PREACCESS_PHASE类型的有ngx_http_limit_req_module和ngx_http_limit_zone_module两个模块，那么它们的ngx_http_limit_req_handler()和ngx_http_limit_zone_handler()就会被调用。在ngx_http_core_generic_phase()里面调用ph->handler(r)之后即控制下一个被调用的函数(是到下一个phase或者是本个phase的下一个handler)。
//NGX_HTTP_ACCESS_PHASE的checker
ngx_http_core_access_phase()
{
rc = ph->handler(r);
//根据rc来判断选择是下一个phase或者是本个phase的下一个handler
//...
}
在模块的默认配置里，NGX_HTTP_ACCESS_PHASE类型的是ngx_http_access_module和ngx_http_auth_basic_module，即ph->handler(r)调用了ngx_http_access_handler()和ngx_http_auth_basic_handler()
//NGX_HTTP_CONTENT_PHASE的checker
ngx_http_core_content_phase()
{
//如果location有特定的handler
//e.g. ngx_http_proxy_module的"proxy_pass"命令就会设置location的handler "ngx_http_proxy_handler"
if (r->content_handler) {
r->write_event_handler = ngx_http_request_empty_handler;
ngx_http_finalize_request(r, r->content_handler(r));
return NGX_OK;
}
//没有location没有特定的handler
rc = ph->handler(r);
ph++;
//跳到下一个NGX_HTTP_CONTENT_PHASE的handler或者下一个phase的checker
if (ph->checker) {
r->phase_handler++;
return NGX_AGAIN;
}
//...
}
默认的配置里有3个NGX_HTTP_CONTENT_PHASE类型的模块有ngx_http_static_module，ngx_http_index_module和ngx_http_autoindex_module，调用它们的ngx_http_static_handler()，ngx_http_index_handler()和ngx_http_autoindex_handler()。
通过实际运行的的debug信息，可以看到每个phase的checker被调用时候的handler的r->phase_handler(即index)。根据实际的情况(如根据不同location配置)，不一定每个handler都会被调用(通过设置r->phase_handler = ph->next)，甚至有时候会直接跳到另外一个phase(比如在ngx_http_index_handler()里面调用ngx_http_internal_redirect()，重新进入ngx_http_handler()，即重新把phase走一遍)。这些都是根据每个phase的handler的实现以及实际的请求来决定的。
关于每个phase的具体功能：
typedef enum {
//0读取请求phase
NGX_HTTP_POST_READ_PHASE = 0,
//1这个阶段主要是处理全局的(server block)的rewrite。
NGX_HTTP_SERVER_REWRITE_PHASE,
//2这个阶段主要是通过uri来查找对应的location，然后根据loc_conf设置r的相应变量
//e.g. 根据location内配置的具体命令设置r->content_handler，到NGX_HTTP_CONTENT_PHASE调用
NGX_HTTP_FIND_CONFIG_PHASE,
//3这个主要处理location的rewrite
NGX_HTTP_REWRITE_PHASE,
//4post rewrite，这个主要是进行一些校验以及收尾工作，以便于交给后面的模块。
NGX_HTTP_POST_REWRITE_PHASE,
//5比如流控这种类型的access就放在这个phase，也就是说它主要是进行一些比较粗粒度的access。
NGX_HTTP_PREACCESS_PHASE,
//6这个比如存取控制，权限验证就放在这个phase，一般来说处理动作是交给下面的模块做的.这个主要是做一些细粒度的access
NGX_HTTP_ACCESS_PHASE,
//7一般来说当上面的access模块得到access_code之后就会由这个模块根据access_code来进行操作
NGX_HTTP_POST_ACCESS_PHASE,
//8try_file模块，也就是对应配置文件中的try_files指令，可接收多个路径作为参数，当前一个路径的资源无法找到，则自动查找下一个路径
NGX_HTTP_TRY_FILES_PHASE,
//9内容处理模块
NGX_HTTP_CONTENT_PHASE,
//10log模块
NGX_HTTP_LOG_PHASE
} ngx_http_phases;
(待续)
