nginx中sub_request的处理

simohayha

首先来看subrequest的处理。

什么是subrequest，顾名思义，那就是子请求，也就是在当前的一个请求中nginx再生成一个请求。比如在nginx的HttpAddition这个filter，就有用到subrequest。

这里要注意，一个subrequest是当父reuest执行完毕后才会被执行，并且它会将所有的需要进行的handler phase重新执行一遍(这个我们后面的代码会看到).

这里还涉及到一个很关键的filter，那就是postpone filter,这个filter就用来缓存住父request，这里的缓存就是将需要发送的数据保存到一个链表中。这个是因为会先执行subrequest，然后才会执行request，因此如果有subrequest的话，这个filter就会跳过后面的发送filter，直接返回ok。

sub request是通过post pone filter以及finalize_request，还有下面的三个域来配合实现的，接下来我们会一个个的分析。

因此这里有这样三个概念，一个是postpone_request,一个是post_request，一个是post_subrequest.其实这三个也就是request的三个域了：

//这个表示主的request，也就是当前的request链中最上面的那个request，通过这个域我们就能判断当前的request是不是subrequest。ngx_http_request_t               *main;//这个表示当前的request的父request。    ngx_http_request_t               *parent;//最关键就是下面三个域。    ngx_http_postponed_request_t     *postponed;    ngx_http_post_subrequest_t       *post_subrequest;    ngx_http_posted_request_t        *posted_requests;

ok，我们一个个来看，先来看postponed，这个域用来缓存父request的数据（也就是将要发送数据的request)，而缓存这个动作是在postpone filter中来做的，我们后面回来分析这个filter。下面就是它的结构：

struct ngx_http_postponed_request_s {    ngx_http_request_t               *request;    ngx_chain_t                      *out;    ngx_http_postponed_request_t     *next;};

可以看到它就是一个很简单的链表，三个域的意思分别为：
request 保存了subrequest
out保存了所需要发送的chain。
next保存了下一个postpone_request.

然后是post_subrequest,这个域保存了子请求的post request，它也就是保存了需要被发送的request. 来看它的结构：

typedef struct {    ngx_http_post_subrequest_pt       handler;    void                             *data;} ngx_http_post_subrequest_t;

可以看到它的结构更加简单，一个handler，保存了到时需要执行的回掉函数，一个data，保存了传递的数据。

最后是posted_requests，这个保存了所有的需要处理的request链表，也就是说它即包含子请求也包含父请求。来看它的结构：

struct ngx_http_posted_request_s {    ngx_http_request_t               *request;    ngx_http_posted_request_t        *next;};

request保存了需要处理的request，next保存了下一个需要处理的request。

然后我们来详细分析sub request的处理流程以及代码，这里代码的分析顺序是按照sub request的流程来的。

首先来看sub request的设置函数ngx_http_subrequest。

这个函数的主要功能就是新建一个request，然后设置对应的属性，其中大部分属性都是和父request相同的，还有一些特殊的sub request独有的属性我们会在下面的代码中分析到(主要是我上面介绍的4个域)。

这个函数的参数比较多，有6个参数，来看它的原型：
ngx_int_tngx_http_subrequest(ngx_http_request_t *r,    ngx_str_t *uri, ngx_str_t *args, ngx_http_request_t **psr,    ngx_http_post_subrequest_t *ps, ngx_uint_t flags)
r表示需要生成子请求的request，uri表示子请求的uri，args表示子请求的参数，psr表示最终生成的子请求，ps表示子请求的post_subrequest，flags主要控制sub request的内容是否要放到内存中。

代码比较长，我们分开来看，下面这段是相关的初始化：

ngx_connection_t              *c;    ngx_http_request_t            *sr;    ngx_http_core_srv_conf_t      *cscf;    ngx_http_postponed_request_t  *pr, *p;//subrequest表示了当前还可以处理的最大个数的sub request，这个值的默认值是50.表示nginx中能够处理的最多的嵌套子请求的个数是50.    r->main->subrequests--;//如果为0,则表示已达到最大的限制，因此返回error。    if (r->main->subrequests == 0) {        ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,                      "subrequests cycle while processing \"%V\"", uri);        r->main->subrequests = 1;        return NGX_ERROR;    }//新建一个sub request。    sr = ngx_pcalloc(r->pool, sizeof(ngx_http_request_t));    if (sr == NULL) {        return NGX_ERROR;    }    sr->signature = NGX_HTTP_MODULE;//设置connection。    c = r->connection;    sr->connection = c;//下面的初始化大部分都是和父请求一样的。    sr->ctx = ngx_pcalloc(r->pool, sizeof(void *) * ngx_http_max_module);    if (sr->ctx == NULL) {        return NGX_ERROR;    }    if (ngx_list_init(&sr->headers_out.headers, r->pool, 20,                      sizeof(ngx_table_elt_t))        != NGX_OK)    {        return NGX_ERROR;    }......................................................    sr->request_body = r->request_body;//可以看到子请求只会是Get方法。    sr->method = NGX_HTTP_GET;    sr->http_version = r->http_version;    sr->request_line = r->request_line;

接下来这段也是初始化，只不过主要是初始化一些sub request特有的属性。这里最关键的就是两个事件处理函数的赋值，read_event_handler和write_event_handler 。其中读事件的handler被赋值为一个空的函数，也就是在sub request中，不会处理读事件。而写事件的handler被赋值为ngx_http_handler，这个函数我们知道，它就是整个nginx的handler处理的入口，因此也就是说sub request最终会把所有的phase再重新走一遍。

这里还要注意，那就是父请求可能会有多个儿子请求。
//子请求的uri    sr->uri = *uri;    if (args) {//参数设置        sr->args = *args;    }    ngx_log_debug2(NGX_LOG_DEBUG_HTTP, c->log, 0,                   "http subrequest \"%V?%V\"", uri, &sr->args);//子请求的内容是否需要放到内存中。    sr->subrequest_in_memory = (flags & NGX_HTTP_SUBREQUEST_IN_MEMORY) != 0;//这个貌似是ssi用到的。    sr->waited = (flags & NGX_HTTP_SUBREQUEST_WAITED) != 0;..............................................................................    ngx_http_set_exten(sr);//设置main，也就是最上层的那个request。    sr->main = r->main;//设置父request    sr->parent = r;//可以看到ost_subrequest 被设置为我们传递进来的值。    sr->post_subrequest = ps;//读写事件的处理函数的赋值    sr->read_event_handler = ngx_http_request_empty_handler;    sr->write_event_handler = ngx_http_handler;//设置连接的request为子请求。这里的意思是如果父请求设置第二个子请求的话，这里就不需要设置连接的request了。    if (c->data == r && r->postponed == NULL) {        c->data = sr;    }    sr->variables = r->variables;    sr->log_handler = r->log_handler;//开始赋值postponed request.    pr = ngx_palloc(r->pool, sizeof(ngx_http_postponed_request_t));    if (pr == NULL) {        return NGX_ERROR;    }//它的request设置为子请求，也就是每个子请求都会用一个postponed request包装起来。    pr->request = sr;    pr->out = NULL;    pr->next = NULL;//如果是第一次给父请求设置孩子，那么将pr放到postponed链表的结尾。    if (r->postponed) {        for (p = r->postponed; p->next; p = p->next) { /* void */ }//找到尾部，然后插入。        p->next = pr;    } else {//否则直接设置        r->postponed = pr;    }//设置内部标记    sr->internal = 1;    sr->discard_body = r->discard_body;    sr->expect_tested = 1;    sr->main_filter_need_in_memory = r->main_filter_need_in_memory;    sr->uri_changes = NGX_HTTP_MAX_URI_CHANGES + 1;//subrequests加1.    r->main->subrequests++;//保存生成的sub request，以供外部使用。    *psr = sr;//设置post request。    return ngx_http_post_request(sr);}

上面的代码有个有疑问的地方，那就是subrequests，我查了下代码只有这个函数里面有对它进行操作，可是这里前面--，后面++，那不是基本没有可能这个值是0。

前面的代码我们可以看到最后会调用ngx_http_post_reques来处理，这个函数是用来讲subrequest放到post request中的。

而post request的调用我会在后面分析到。

ngx_int_tngx_http_post_request(ngx_http_request_t *r){    ngx_http_posted_request_t  *pr, **p;//新建一个post request。    pr = ngx_palloc(r->pool, sizeof(ngx_http_posted_request_t));    if (pr == NULL) {        return NGX_ERROR;    }//设置request为sub request.    pr->request = r;    pr->next = NULL;//找到post request的尾部。    for (p = &r->main->posted_requests; *p; p = &(*p)->next) { /* void */ }//然后赋值。    *p = pr;    return NGX_OK;}

然后来看postpone 这个filter，这个filter就是用来缓存父request的chain， 并且控制sub request的发送。

代码分段来看，先来看第一部分，这部分主要是处理父请求进来的情况，也就是缓存父请求的chain。

ngx_connection_t              *c;    ngx_http_postponed_request_t  *pr;//取得当前的链接    c = r->connection;//如果r不等于c->data,前面的分析知道c->data保存的是最新的一个sub request(同级的话，是第一个),因此不等于则说明是需要保存数据的父request。    if (r != c->data) {        if (in) {//保存数据(下面会分析这段代码)            ngx_http_postpone_filter_add(r, in);//这里注意不发送任何数据，直接返回OK。而最终会在finalize_request中处理。            return NGX_OK;        }        return NGX_OK;    }//如果r->postponed为空，则说明是最后一个sub request，也就是最新的那个，因此需要将它先发送出去。    if (r->postponed == NULL) {//如果in存在，则发送出去        if (in || c->buffered) {            return ngx_http_next_filter(r->main, in);        }        return NGX_OK;    }
然后来看ngx_http_postpone_filter_add这个方法，这个方法主要是拷贝当前需要发送的chain到postponed的out域中。

这里要注意一个的就是由于filter有可能会进入多次，因此如果相同的request的in chain会拷贝到相同的posrponed request中。

还有这里要注意就是这里添加的postponed request的request域是NULL，也就是说明这个postponed request就是自己，也就是r==r->postponed->request.

static ngx_int_tngx_http_postpone_filter_add(ngx_http_request_t *r, ngx_chain_t *in){    ngx_http_postponed_request_t  *pr, **ppr;//如果postponed存在，则进入相关处理    if (r->postponed) {//找到postponed的尾部        for (pr = r->postponed; pr->next; pr = pr->next) { /* void */ }//如果为空，则直接添加到当前的chain        if (pr->request == NULL) {            goto found;        }        ppr = &pr->next;    } else {        ppr = &r->postponed;    }    pr = ngx_palloc(r->pool, sizeof(ngx_http_postponed_request_t));    if (pr == NULL) {        return NGX_ERROR;    }    *ppr = pr;//可以看到request是空。    pr->request = NULL;    pr->out = NULL;    pr->next = NULL;found://最终复制in到pr->out,也就是保存request 需要发送的数据。    if (ngx_chain_add_copy(r->pool, &pr->out, in) == NGX_OK) {        return NGX_OK;    }    return NGX_ERROR;}

然后再回到ngx_http_postpone_filter，剩下的这段代码主要就是用来发送前面保存的父请求的chain.

//到达这里说明需要发送父请求的数据了。if (in) {//如果有chain，则保存数据。        ngx_http_postpone_filter_add(r, in);    }//开始遍历postponed request.    do {        pr = r->postponed;//如果存在request，则说明这个postponed request是sub request，因此需要将它放到post_request中。        if (pr->request) {            ngx_log_debug2(NGX_LOG_DEBUG_HTTP, c->log, 0,                           "http postpone filter wake \"%V?%V\"",                           &pr->request->uri, &pr->request->args);            r->postponed = pr->next;            c->data = pr->request;//放到post request中。            return ngx_http_post_request(pr->request);        }        if (pr->out == NULL) {            ngx_log_error(NGX_LOG_ALERT, c->log, 0,                          "http postpone filter NULL output",                          &r->uri, &r->args);        } else {//说明pr->out不为空，此时需要将保存的父request的数据发送。            ngx_log_debug2(NGX_LOG_DEBUG_HTTP, c->log, 0,                           "http postpone filter output \"%V?%V\"",                           &r->uri, &r->args);//发送            if (ngx_http_next_filter(r->main, pr->out) == NGX_ERROR) {                return NGX_ERROR;            }        }        r->postponed = pr->next;    } while (r->postponed);

然后我们来看ngx_http_finalize_request中sub request的处理部分，其实ngx_http_finalize_request中，一大部分都是sub request的处理，

这个处理其实主要就是修改一开始介绍的request的三个域。

这里要注意，由于如果有sub request的话，postponed filter会返回NGX_OK。

还有就是所有需要处理的request都必须放入到post request中，儿postponed request中保存的是暂时缓存的不需要发送的request。
   //如果r不等于r->main的话，则说明当前的请求是是sub request，此时进入相关处理。 if (r != r->main) {//如果含有postponed的话，则说明这个request并不是最后一个sub request，因此设置write handler，并且返回。        if (r->buffered || r->postponed) {            if (ngx_http_set_write_handler(r) != NGX_OK) {                ngx_http_close_request(r->main, 0);            }            return;        }//取得request的父request        pr = r->parent;//如果r等于c->data,则说明当前是最后一个sub request，此时需要修改c->data,以便于在postponed filter中发送保存的父request的数据。        if (r == c->data) {...................................................................            r->done = 1;//如果父request的postponed存在并且它的request为当前的r，则开始处理接下来的postponed。            if (pr->postponed && pr->postponed->request == r) {//取next                pr->postponed = pr->postponed->next;            }//修改c->data,这个将会在run_post_request中使用，接下来就会分析这个函数。            c->data = pr;        } else {//否则则设置write handler.            r->write_event_handler = ngx_http_request_finalizer;            if (r->waited) {                r->done = 1;            }        }//最终将pr也就是父request放入到post request中。        if (ngx_http_post_request(pr) != NGX_OK) {            ngx_http_close_request(r->main, 0);            return;        }..............................................        return;    }

上面有一个函数那就是ngx_http_set_write_handler，这个用来设置write handler,这里是这是write handler为ngx_http_writer，而我们要知道sub request的处理是，不停的保存父request的chain(在postponed filter中),而每次保存完毕之后就返回ngx_ok,此时由于这个request已经经历完毕所有的handler phase，因此我们就需要修改它的write handler，以便于需要发送的时候跳过handler 阶段，因此就设置ngx_http_writer，这个函数主要就是调用out_put filter,而不经过handler phase。

最后我们来看post request的调用在那里。

在nginx中，request的执行是在ngx_http_process_request中的，来看这个函数的最后两句：

//处理request，每个sub request在处理之前的write handler 都是这个函数。ngx_http_handler(r);//开始run post request    ngx_http_run_posted_requests(c);

我们来详细看ngx_http_run_posted_requests的实现。这个函数就是遍历post request,然后调用它的write handler对request进行处理。

voidngx_http_run_posted_requests(ngx_connection_t *c){    ngx_http_request_t         *r;    ngx_http_log_ctx_t         *ctx;    ngx_http_posted_request_t  *pr;//开始遍历    for ( ;; ) {//如果连接已经被销毁，则直接返回。        if (c->destroyed) {            return;        }//取出c->data(可以看到在finalize request中会修改到这个域的,也就是这个域会始终保存最新的sub request（也就是将要被发送的request).        r = c->data;        pr = r->main->posted_requests;        if (pr == NULL) {            return;        }//赋值为下一个。        r->main->posted_requests = pr->next;        r = pr->request;        ctx = c->log->data;        ctx->current_request = r;//调用write handler.        r->write_event_handler(r);    }}