|
1
2
3
4
5
6
7
8
9
10 11
12
13
14
15
16
17
18
19
20
21
|
void
ngx_http_handler(ngx_http_request_t * r)
{
…. ....................................
headers_in.connection_type) {
case0://If the version is greater than 1.0, the default is keepalive
r- >keepalive = (r->http_version > NGX_HTTP_VERSION_10);
//If the connection header is specified as close, keepalive is not required }................................
}
Then we know that keepalive means that the current connection will not be closed directly after the current http request is executed, so the related processing of nginx's keepalive is also the function to clean up the request. nginx’s function to clean up requst is ngx_http_finalize_request. In this function, ngx_http_finalize_connection is called to release the connection, and the relevant judgment of keepalive is in this function.
|
1
2
3
4
5
6
7
8
9
10 11
12
13
14
15
16
17
18
19
20
21
22
23
|
staticvoid
ngx_http_finalize_connection(ngx_http_request_t *r)
{
ngx_http_core_loc_conf_t *clcf;
clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);
. ..................... ................................................
//You can see that if keepalive is set and timeout is greater than 0, keepalive processing will be entered.
r->keepalive
&& clcf->keepalive_timeout > 0) {
ngx_http_set_keepalive(r);
if
return;
} ngx_http_close_request(r, 0);
}
From the above we can see that keepalive is set through ngx_http_set_keepalive. Next we will look at this function in detail. In this function, pipeline requests will be processed incidentally, so let’s take a look at it together. First, how nginx distinguishes pipeline requests. It will assume that if the data read from the client contains more data, that is, parsing After completing the current request, there is still some data. At this time, it is considered a pipeline request. Another very important point is http_connection. We know from the previous blog that if we need to alloc a large header, it will be taken from hc->free first. If not, it will be created and then handed over to hc-> ;Busy to manage. And this buf will be reused here, because if the large buf is large, it needs to be re-allocated a second time. If the buf is reused here, one allocation will be reduced.
|
1
2
3
4
5
6
7
8
9
10 11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
2 7
28
29
30
31 32
33
34
35
36
37
38
39
40
41
|
hc = r->http_connection;
b = r->header_in;
//Generally, after parsing header_in, pos will be set to last. That is to say, the data read is just a complete http request. When pos is less than last, it means it may be a pipeline request.
if(b->pos < b->last) {
if
(b != c->buffer) { * request processing then we do not use c-> buffer for
* Now we would move the large header buffers to the free list.
*/
== NULL) {
//You can see the number of large_client_headers
(ngx_buf_t *)); <p><code> }
//Then clean up the busy of the current request
1; i++) {
f = hc->busy[i];
f->pos = f->start; er_in buf for free use next time .
}
}
Then the next part is the free request and setting the keepalive timer.
12
345
6 78 91011
12
| 13 14 15
r->keepalive = 0; |
ngx_http_free_request(r, 0);
c->data = hc;
//Set timer
ngx_add_timer(rev, clcf->keepalive_timeout);
//Then set readable Event
| if
(ngx_handle_read_event(rev, 0) != NGX_OK) {
ngx_http_close_connection(c);
return;
}
wev = c->write;
wev->handler = ngx_http_empty_handler; Then the next part is the processing of the pipeline.
12
3456
789
10 1112 1314 15
|
if(b->pos < b->last) {
>log|
,
0,
"pipelined request"
);
#if (NGX_STAT_STUB)
_reading,
1);
#endif
//Set tag.
"reading client pipelined request line"
;
|
//Then throw it into the post queue and continue processing.
When it reaches the bottom, it means that it is not a pipeline request, so we start to clean up the request and http_connection.
|
1
2
3
4
5
6
7
8
9
10 11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
2 7
28
29
30
|
}
b = c->buffer;
if(ngx_pfree(c->pool, b->start) == NGX_OK) {
* the special note for ngx_http_keepalive_handler() that * c->buffer's memory was freed
}
"
(i = 0; i < hc->nbusy; i++) {
1
3
7
The last thing is the processing of tcp push. I won’t introduce it here for now. Next, I will have a special blog to introduce nginx’s operation of tcp push. Then let’s look at the ngx_http_keepalive_handler function. This function handles the keepalive connection. When there is a readable event on the connection again, this handler will be called. This handler is relatively simple, it just creates a new buf, and then restarts the execution of an http request (calling ngx_http_init_request).
|
1
2
3
4
5
6
7
8
9
10 11
12
13
14
15
16
17
18
19
20
21
|
if
(b->pos == NULL) {/*
* The c->buffer's memory was freed by ngx_http_set_keepalive(). . ->pos == NULL) { ->pos;
1
4 5
8
;
|
Finally, if the data is read, enter request processing.
1
ngx_http_init_request(rev);
Finally, let’s look at the ngx_http_init_request function. This time we mainly look at how nginx reuses the request when the pipeline is requested.
Pay attention to hc->busy[0] here. We know earlier that if it is a pipeline request, we will save the request header_in that has not been parsed before. This is because we may have read the second request of the pipeline request. Some heads.
|
1
2
3
4
5
6
7
8
9
10 11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
|
//Get the request, here we know that in the pipeline request , we will save the previous request.
r = hc->request;
if(r) {
//If it exists, we reuse the previous request .
sizeof(ngx_http_request_t));
r->pipeline = hc->pipeline;
//If nbusy exists
;nbusy) {//Save this header_in, and then parse it directly below. GR-& gt; header_in = hc-& gt; busy [0];
}}
}
else{
r = ngx_pcalloc(c->pool,
sizeof(ngx_http_request_t)); _connection(c);
The above introduces nginx's analysis of keepalive and pipeline request processing, including aspects of the process. I hope it will be helpful to friends who are interested in PHP tutorials.
|
|
|
|
|
|
