菜鸟学习nginx之结束HTTP请求

最新推荐文章于 2023-08-05 23:05:51 发布
最新推荐文章于 2023-08-05 23:05:51 发布
阅读量4.1k 收藏
点赞数
分类专栏： 开源软件 Nginx 文章标签： Nginx关闭连接 ngx_http_finalize_request
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xxb249/article/details/85395032
版权

当我们发送响应的时候，意味着我们即将结束当前HTTP请求，注意这里并不是关闭TCP连接，因此TCP连接可能正用在其他请求上。Nginx定义了很多接口用关闭HTTP请求，但用的最多还是ngx_http_finalize_request。接下来分析一下它。

一、Nginx管理HTTP核心思想

众所周知，Nginx全异步框架，当一个流程可能需要较长时间占用进程，那么Nginx建议派生出子请求(subrequest)，用于处理当前业务逻辑。这样无疑增加了Nginx复杂度，因为很有可能子请求又会创建新的子请求，那么Nginx是如何管理这些请求呢以及如何确定是否真正关闭请求呢？Nginx使用下面三个参数进行管理(主要参数)：

struct ngx_http_request_s {
    ...
    /* 原始请求 客户端发送过来的HTTP请求 原始请求下main指向自己 */
    ngx_http_request_t               *main;

    /* 当前请求的父请求。未必是原始请求。原始请求的parent为NULL */
    ngx_http_request_t               *parent;
    ...
    /**
     * 表示当前请求引用计数.
     * 1、当派生出一个子请求时，就会把原始请求count加1，当子请求结束的时候count
     *    减1。当子请求再次派生出新的子请求，原始请求count也会加1     
     * 2、当我们接收body的时候，count也会加1，避免在count为0的场景下把请求回调掉。
     * 3、这里所说的原始请求，就是客户端发送过来的http请求
     */
    unsigned                          count:16;
    ...
}

说明：

1、通过main、parent用于管理父子请求间关系，注意main始终指向原始请求。

2、count参数是计数器，当count为0时，就要真正销毁请求。

二、函数ngx_http_finalize_request

/**
 * 结束HTTP请求
 * @param r   http请求
 * @param rc  一般是发送header或者body函数的返回值
 */
void ngx_http_finalize_request(ngx_http_request_t *r, ngx_int_t rc)
{
    ngx_connection_t *c;
    ngx_http_request_t *pr;
    ngx_http_core_loc_conf_t *clcf;

    c = r->connection;

    ngx_log_debug5(NGX_LOG_DEBUG_HTTP, c->log, 0,
                   "http finalize request: %i, \"%V?%V\" a:%d, c:%d",
                   rc, &r->uri, &r->args, r == c->data, r->main->count);

    if (rc == NGX_DONE)
    {
        ngx_http_finalize_connection(r);//结束连接 只有count为0时才会真正关闭连接
        return;
    }

    if (rc == NGX_OK && r->filter_finalize)
    {
        c->error = 1;
    }

    if (rc == NGX_DECLINED)
    {//再次执行流水线
        r->content_handler = NULL;
        r->write_event_handler = ngx_http_core_run_phases;
        ngx_http_core_run_phases(r);
        return;
    }

 说明：

1)当返回码为NGX_DONE表示为所有流程都已经完成，正常关闭连接

2)当返回码为NGX_DECLINED表示流程还没有完全结束，例如发送body场景，还有一部分没有发送成功，需要重新进入流水线执行。

    /* 如果是子请求 则进行子请求的handler处理 */
    if (r != r->main && r->post_subrequest)
    {
        rc = r->post_subrequest->handler(r, r->post_subrequest->data, rc);
    }

    /* 错误、超时、客户端关闭连接 或者其他错误 */
    if (rc == NGX_ERROR || rc == NGX_HTTP_REQUEST_TIME_OUT || rc == NGX_HTTP_CLIENT_CLOSED_REQUEST || c->error)
    {
        if (ngx_http_post_action(r) == NGX_OK)
        {
            return;
        }

        if (r->main->blocked)
        {
            r->write_event_handler = ngx_http_request_finalizer;
        }

        ngx_http_terminate_request(r, rc);//强制终止请求
        return;
    }
    /* 处理特殊错误 */
    if (rc >= NGX_HTTP_SPECIAL_RESPONSE || rc == NGX_HTTP_CREATED || rc == NGX_HTTP_NO_CONTENT)
    {
        if (rc == NGX_HTTP_CLOSE)
        {
            ngx_http_terminate_request(r, rc);//强制终止请求
            return;
        }

        if (r == r->main)
        {//当前请求为原始请求 删除定时器
            if (c->read->timer_set)
            {
                ngx_del_timer(c->read);
            }

            if (c->write->timer_set)
            {
                ngx_del_timer(c->write);
            }
        }

        c->read->handler = ngx_http_request_handler;
        c->write->handler = ngx_http_request_handler;

        ngx_http_finalize_request(r, ngx_http_special_response_handler(r, rc));
        return;
    }

以上代码流程主要是用于错误信息处理。

    /* 表示当前请求不是原始请求 */
    if (r != r->main)
    {
        if (r->buffered || r->postponed)
        {

            if (ngx_http_set_write_handler(r) != NGX_OK)
            {
                ngx_http_terminate_request(r, 0);//强制终止请求
            }

            return;
        }

        pr = r->parent;

        if (r == c->data)
        {

            r->main->count--;

            if (!r->logged)
            {

                clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

                if (clcf->log_subrequest)
                {
                    ngx_http_log_request(r);
                }

                r->logged = 1;
            }
            else
            {
                ngx_log_error(NGX_LOG_ALERT, c->log, 0,
                              "subrequest: \"%V?%V\" logged again",
                              &r->uri, &r->args);
            }

            r->done = 1;

            if (pr->postponed && pr->postponed->request == r)
            {
                pr->postponed = pr->postponed->next;
            }

            c->data = pr;
        }
        else
        {

            ngx_log_debug2(NGX_LOG_DEBUG_HTTP, c->log, 0,
                           "http finalize non-active request: \"%V?%V\"",
                           &r->uri, &r->args);

            r->write_event_handler = ngx_http_request_finalizer;

            if (r->waited)
            {
                r->done = 1;
            }
        }

        if (ngx_http_post_request(pr, NULL) != NGX_OK)
        {
            r->main->count++;
            ngx_http_terminate_request(r, 0);
            return;
        }

        ngx_log_debug2(NGX_LOG_DEBUG_HTTP, c->log, 0,
                       "http wake parent request: \"%V?%V\"",
                       &pr->uri, &pr->args);

        return;
    }

    /* 当前请求是原始请求 */
    if (r->buffered || c->buffered || r->postponed || r->blocked)
    {

        if (ngx_http_set_write_handler(r) != NGX_OK)
        {
            ngx_http_terminate_request(r, 0);
        }

        return;
    }

    if (r != c->data)
    {
        ngx_log_error(NGX_LOG_ALERT, c->log, 0,
                      "http finalize non-active request: \"%V?%V\"",
                      &r->uri, &r->args);
        return;
    }

    r->done = 1;
    r->write_event_handler = ngx_http_request_empty_handler;

    if (!r->post_action)
    {
        r->request_complete = 1;
    }

    if (ngx_http_post_action(r) == NGX_OK)
    {
        return;
    }
    /* 删除定时器 */
    if (c->read->timer_set)
    {
        ngx_del_timer(c->read);
    }

    if (c->write->timer_set)
    {
        c->write->delayed = 0;
        ngx_del_timer(c->write);
    }

    if (c->read->eof)
    {
        ngx_http_close_request(r, 0); //判断count是否为0
        return;
    }
    //关闭连接
    ngx_http_finalize_connection(r);
}

三、遗留问题

1、在前面几篇一直提升成员参数count，当count为0时才会真正关闭请求对象，如果非0则不关闭，那么到底在哪个函数中进行逻辑判断呢？

2、在上面流程中，我们看到了关闭流程，那么对于HTTP请求长连接是如何处理的呢？

以上两个问题都在函数ngx_http_finalize_connection有体现，该函数在ngx_http_finalize_request函数中有调用。

/**
 * 关闭连接
 * @param r http请求
 */
static void
ngx_http_finalize_connection(ngx_http_request_t *r)
{
    ngx_http_core_loc_conf_t *clcf;

#if (NGX_HTTP_V2)
    if (r->stream)
    {
        ngx_http_close_request(r, 0);
        return;
    }
#endif

    clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

    if (r->main->count != 1)
    {

        if (r->discard_body)
        {
            r->read_event_handler = ngx_http_discarded_request_body_handler;
            ngx_add_timer(r->connection->read, clcf->lingering_timeout);

            if (r->lingering_time == 0)
            {
                r->lingering_time = ngx_time() + (time_t)(clcf->lingering_time / 1000);
            }
        }

        ngx_http_close_request(r, 0);
        return;
    }

    if (r->reading_body)
    {
        r->keepalive = 0;
        r->lingering_close = 1;
    }

    if (!ngx_terminate && !ngx_exiting && r->keepalive && clcf->keepalive_timeout > 0)
    {//采用keepalive方式 管理连接 
        ngx_http_set_keepalive(r);
        return;
    }

    if (clcf->lingering_close == NGX_HTTP_LINGERING_ALWAYS || (clcf->lingering_close == NGX_HTTP_LINGERING_ON && (r->lingering_close || r->header_in->pos < r->header_in->last || r->connection->read->ready)))
    {
        ngx_http_set_lingering_close(r);
        return;
    }
    /* 判断count是否为0 如果为0则关闭请求以及tcp连接 */
    ngx_http_close_request(r, 0);
}

3.1、判断count是否为0

static void
ngx_http_close_request(ngx_http_request_t *r, ngx_int_t rc)
{
    ngx_connection_t *c;

    r = r->main;
    c = r->connection;

    ngx_log_debug2(NGX_LOG_DEBUG_HTTP, c->log, 0,
                   "http request count:%d blk:%d", r->count, r->blocked);

    if (r->count == 0)
    {
        ngx_log_error(NGX_LOG_ALERT, c->log, 0, "http request count is zero");
    }

    r->count--;
    /**
     * 如果count非0表示还有其他子请求或者动作需要处理 不能直接关闭
     * 如果blocked非0表示阻塞，不能直接关闭 此参数用于aio(异步io)
     */
    if (r->count || r->blocked)
    {
        return;
    }

#if (NGX_HTTP_V2)
    if (r->stream)
    {
        ngx_http_v2_close_stream(r->stream, rc);
        return;
    }
#endif

    ngx_http_free_request(r, rc);
    ngx_http_close_connection(c);
}

3.2、keep-alive长连接处理

对于长连接处理，实现函数为ngx_http_set_keepalive。在内部处理会关闭当前请求却不关闭tcp连接，但是会设置定时器，当定时器到期后会把tcp连接关闭掉。这里不深入介绍keepalive机制了。

四、总结

至此，Nginx关闭连接请求流程介绍完毕。自我感觉对于关闭连接请求函数，理解不是深刻，日后工作中若能加深印象，会再次编辑此页面，重新梳理流程。

xxb249
关注
专栏目录
Centos 6.9 关闭http,Nginx版本信息
极致，细节
06-05 2225
http隐藏版本信息 vi /etc/httpd/conf/httpd.conf 44 ServerTokens Prod 536 ServerSignature Off 重启http service httpd restart ========================================================= Nginx隐藏版本信息
Nginx学习笔记(基础版)docker&docker-compose安装部署
我就吃一口的BLOG
03-16 3948
Nginx学习笔记 一、 什么是Nginx Nginx 是一款轻量级的 Web 服务器/反向代理服务器及电子邮件（IMAP/POP3）代理服务器 二、 Nginx的优缺点 2.1 优点： 1. 占内存小，可实现高并发连接，处理响应快 2. 可实现http服务器、虚拟主机、方向代理、负载均衡 3. Nginx配置简单 4. 可以不暴露正式的服务器IP地址 2.2 缺点： 动态处理差：nginx处理静态文件好,耗费内存少，但是处理动态页面则很鸡肋，现在一般前端用nginx
NGINX配置禁用http请求方式
qq_36842015的博客
10-17 3711
Nginx配置禁用http请求
Nginx开启或者关闭http可以访问https不行
琅枫的博客
05-09 681
经过检查发现没有用firewalld防火墙，用的iptables。在Nginx目录下输入命令检查是否开启。以上这是开启nginx之后的效果。防火墙把路有器的转发拦截掉了。
HTTP请求的发起与结束流程
CCWAaaaa的博客
12-29 585
HTTP请求 HTTP 目前的主流版本是1.X，它是一种无状态的协议。 什么叫做无状态 无状态是值Web浏览器和Web服务器之间不需要建立持久的连接，这意味着当一个客户端向服务器端发出请求，然后Web服务器返回响应，连接就被关闭了，在服务端不保留连接的有关信息，即当一次连接结束后，并不能知道之前是谁连接了。 HTTP遵循请求(Request)/应答(Response)模型。 Web浏览器向Web服务器发送请求，Web服务器处理请求并返回适当的应答。所有HTTP连接都被构造成一套请求
NGINX源码之：子请求与请求后置处理ngx_http_finalize_request
qq_22351805的博客
10-31 924
ngx_http_finalize_request流程解读、ngx_http_subrequest子请求说明、ngx_http_finalize_connection、ngx_http_close_request、ngx_close_connection
CentOS7下安装nginx及配置
最新发布
sinat_36733279的博客
08-05 595
配置nginx的配置文件nginx.conf文件(文件在conf下)，主要也就是端口。找到压缩包进行解压，可将压缩包上传至/usr/local/java下，进行解压。1、修改端口，将下面这个地方的80修改成自己想要的端口号如：81端口。切换目录到/usr/local/nginx/sbin下面。2、重新加载修改的文件，并在防火墙中开启自定义端口。可以按照自己服务器的端口使用情况来进行配置。3、本机再次访问 Linux IP ：81。查看nginx服务是否启动成功。说明安装和配置都没问题OK了。
win10下docker部署nginx+node+mongodb+redis学习
天极小强的博客
08-30 927
环境介绍 docker的好处有很多，这里就不多说了，win10上安装docker要求是专业版的win10，而我们一般买的是家庭版的，家庭版可以通过激活码升级成专业版，至于激活码，读者们可以去某宝买，不贵。当然win10家庭版上也可以通过一些复杂的配置让其能跑docker，这个可以自行百度。 我这里假定读者们已经在win10中安装并配置好docker，这里我就简单的说一下我的docker配置吧。 ...
Linux命令、nginx反向代理服务器、shell脚本
Aimeiyyds的博客
07-30 908
Linux常用命令，nginx，shell脚本
Linux服务器端离线安装nginx+uwsgi+flask环境
天真不无邪，hello和world
05-07 954
硬件环境 操作系统：Linux Ubuntu 16.04.12 ~$ cat /proc/version Linux version 4.15.0-72-generic (buildd@lcy01-amd64-023) (gcc version 5.4.0 20160609 (Ubuntu 5.4.0-6ubuntu1~16.04.12)) #81~16.04.1-Ubuntu SMP Tu...
nginx关闭请求处理ngx_http_finalize_request源码分析
focus on security
01-04 1636
ngx_http_finalize_request 各个http模块在执行完某个操作都需要调用这个函数，来把请求的引用计数减去1，当引用计数为0时才会真正释放一个请求。这个函数实现比较复杂，考虑了各种场景，我们分别来看下这些场景。 (1)当执行某个操作结束后： 例如把读事件从epoll红黑树中删除时。 这个操作执行完成后，会调用这个函数，表示这个操作已经完成了，需要把这个操作对应的引用计数给减去1：典型的还比如upstream结束，子请求结束等调用。 //由各个http模块调用的，释放h...
Day 219/300 如何终止发请求
xinghuowuzhao的博客
04-30 370
（一）需求 被问到如何终止发送的HTTP请求时，被问到了，于是总结记录如下。 （二）终止请求的三种方式 1、终止一个XHR请求 var xhr=XMLHttpRequest; xhr.abort() 2、终止Fetch AbortController.abort() 与 XHR 的 abort() 方法不同的是，AbortController.abort() 方法一旦被调用，则被标记的 Fetch 不可再次发起请求，这一点和 Axios 中终止请求的机制是一致的。 3、终止一个 Axios 请求 var
Nginx 请求处理流程
l619872862的博客
10-28 1444
Nginx请求处理流程 多种流量进入nginx后,nginx的三种状态机[非阻塞驱动模型epoll]: 传输层状态机,http状态机,mail状态机，在nginx解析出请求后,会动用线程池处理调用,将静态资源,反向代理,错误日志等信息分别导向不同的出口,如: fastcgi会导向php处理,html会导向nginx处理.并将处理的请求记录日志到本地或远程服务器 接受请求事件模块 三次握手,当用户发来一个 SYN 报文时,系统内核会返回一个SYN+ACK确认给客户端,当用户再次发送ACK来的时候,此时
使用Nginx进行代理，出现大量CLOSE WAIT状态的线程的处理方法
时间之沙
11-24 2703
问题背景： 在使用nginx进行代理下载文件的时候，发现有大量文件下载失败，使用lsof命令查看后，发现有大量的线程状态处理CLOSE WAIT的状态，导致占用了大量的线程，并且无法释放，所以需要及时的进行处理 解决思路： 方法一（从系统层面解决）： #vim /etc/sysctl.conf 增加 net.ipv4.tcp_keepalive_time=30 net.ipv4.tcp_keepalive_probes=2 net.ipv4.tcp_keepalive_intvl=2 #sysctl -p
[nginx]统计文件下载是否完整思路（flask）
orangleliu 笔记本
03-12 4878
有一个需求是统计文件是否被用户完整下载，因为是web应用，用js没有找到实现方案，于是搜索下nginx的实现方案，把简单的探索过程记录下。 实验一 最原始的思路，查看日志，下载了一个文件之后我们看日志的传输的文件大小跟文件原始的大小是否一致 测试要下载的文件的大小一次完整下载的log 跟一次没下载完成的log，可以通过对比传输字节的大小来判断 这种方式就是根据日志来做统计，每隔一段时间分析日志得到结
使用Nginx post_action配置 & filter模块中添加定时器 导致的coredump
lhjsx0518的专栏
11-14 2365
环境
nginx释放请求与tcp连接
ApeLife技术博客
07-08 1万+
前面的文章分析了nginx服务器如何接收http请求行、请求头部、然后调用各个模块共同协作处理请求、以及接收包体等过程。现在来分析下nginx服务器是如何结束一个http请求的(关闭http请求与tcp连接)。结束一个http请求的过程就复杂多了，在结束一个请求过程中，nginx考虑了各种可能出现的场景。例如: (1)在客户端访问的文件不存在时，如果指定了error page指令，则在请求结束时发...
nginx 禁用不安全的http方法
wudinaniya的博客
01-10 1万+
从安全防护角度考虑，一般我们要禁用不安全的 HTTP 方法，仅保留 GET、POST 方法。 nginx 禁用不安全的http方法，既可以在nginx配置文件 server 下进行全局设置，也可以在某个location下进行设置。 全局设置方式一 if ($request_method ~ ^(PUT|DELETE)$) { return 40...
nginx处理post请求(http响应头部的收发)
热门推荐
ApeLife技术博客
09-16 2万+
上一篇文章分析了nginx如何发送来自客户端的请求数据到后端服务器， 本篇文章开始将分析nginx如何接收来自后端服务器的响应。nginx接收来自后端服务器的响应分为两个过程，一个是接收来自后端服务器的http响应头部， 另一个是接收来自后端服务器的响应包体。         有必要在最前面说明，也是很重要的几点。(1)nginx在收到来自客户端的全部请求数据后，采用边发送请求数据到后端服务器，
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值