示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
upstream backend {
    server 127.0.0.1:8080;
}

server {
    listen 8000;

    location /path {
        access_by_lua_block {
            ngx.status = 200
            ngx.say("ok")
        }
        set $ups "";
        proxy_pass http://$ups;
    }
}

使用 HTTP1.0 请求会提示 500 错误, 使用 HTTP1.1 则不会:

1
2
3
4
5
$ curl -i -0 "http://127.0.0.1:8000/path"
HTTP/1.1 500 Internal Server Error

$ curl -i "http://127.0.0.1:8000/path"
HTTP/1.1 200 OK

应答上的差异

这是因为 lua-nginx-module 默认开启了 lua_http10_buffering 配置, 在执行输出 ngx.say/ngx.print 操作时会对 HTTP1.0 版本请求进行输出缓存. ngx.say/ngx.print 最终都会调用 ngx_http_lua_send_chain_link 函数, 其中 in 参数是待输出内容.

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
27
28
29
30
31
32
33
34
35
36
ngx_int_t
ngx_http_lua_send_chain_link(ngx_http_request_t *r, ngx_http_lua_ctx_t *ctx, ngx_chain_t *in)
{
    // 忽略无关代码
    llcf = ngx_http_get_module_loc_conf(r, ngx_http_lua_module);

    // 开启 http1.0 缓存功能, 并且请求使用协议版本号小于 1.1
    if (llcf->http10_buffering
        && !ctx->buffering
        && !r->header_sent
        && !ctx->header_sent
        && r->http_version < NGX_HTTP_VERSION_11
        && r->headers_out.content_length_n < 0)
    {
        ctx->buffering = 1;
    }

    // 忽略无关代码

    // 启用输出缓存时并未进行应答输出操作
    if (ctx->buffering) {
        ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
                       "lua buffering output bufs for the HTTP 1.0 request");

        for (cl = ctx->out, ll = &ctx->out; cl; cl = cl->next) {
            ll = &cl->next;
        }

        *ll = in;

        return NGX_OK;
    }

    // 进行应答输出操作
    return ngx_http_lua_output_filter(r, in);
}

为什么 HTTP1.0 会出错

使用 HTTP1.0 协议出错是因为虽然在 access 阶段调用了 ngx.say\ngx.print 进行响应输出, 但是请求最终走到 content 阶段. 在 proxy_pass 模块处理中, 对 proxy_pass 的转发目的进行处理时出现错误.

对于未采用输出响应缓存的请求, 在 access_by_lua 函数执行完毕后会终止请求处理, 不会进入 content 阶段处理.

当请求在 access 阶段将应答头发送出去时, lua-nginx-module 在 acess 阶段执行的应答码为 NGX_HTTP_OK, nginx 的处理函数 ngx_http_core_access_phase 会终止请求执行.

access_by_lua 执行函数:

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
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
static ngx_int_t
ngx_http_lua_access_by_chunk(lua_State *L, ngx_http_request_t *r)
{

    // 创建 access 阶段的协程
    /*  {{{ new coroutine to handle request */
    co = ngx_http_lua_new_thread(r, L, &co_ref);

    if (co == NULL) {
        // ...
        return NGX_HTTP_INTERNAL_SERVER_ERROR;
    }

    /*  move code closure to new coroutine */
    lua_xmove(L, co, 1);

    // ...

    /*  save nginx request in coroutine globals table */
    ngx_http_lua_set_req(co, r);

    /*  {{{ initialize request context */
    ctx = ngx_http_get_module_ctx(r, ngx_http_lua_module);

    dd("ctx = %p", ctx);

    if (ctx == NULL) {
        return NGX_ERROR;
    }

    ngx_http_lua_reset_ctx(r, L, ctx);

    ctx->entered_access_phase = 1;

    ctx->cur_co_ctx = &ctx->entry_co_ctx;
    ctx->cur_co_ctx->co = co;
    ctx->cur_co_ctx->co_ref = co_ref;

    /*  }}} */

    // ...

    ctx->context = NGX_HTTP_LUA_CONTEXT_ACCESS;

    // ...

    c = r->connection;
    nreqs = c->requests;

    // 在协程内进行请求处理, 调用 lua 代码
    rc = ngx_http_lua_run_thread(L, r, ctx, 0);

    if (rc == NGX_ERROR || rc > NGX_OK) {
        return rc;
    }

    // ...

    if (rc == NGX_OK) {
        // 执行完毕, 并且响应头已经发出, 返回 NGX_HTTP_OK
        // 输出应答缓冲区内容
        if (r->header_sent) {
            dd("header already sent");

            /* response header was already generated in access_by_lua*,
             * so it is no longer safe to proceed to later phases
             * which may generate responses again */

            if (!ctx->eof) {
                dd("eof not yet sent");

                rc = ngx_http_lua_send_chain_link(r, ctx, NULL
                                                  /* indicate last_buf */);
                if (rc == NGX_ERROR || rc > NGX_OK) {
                    return rc;
                }
            }

            return NGX_HTTP_OK;
        }

        // 未发送响应头时返回 NGX_OK, 在 nginx 中会继续执行后续阶段
        return NGX_OK;
    }

    return NGX_DECLINED;
}

lua_http10_buffering 指令

  • syntax: lua_http10_buffering on|off

  • default: lua_http10_buffering on

  • context: http, server, location, location-if

启用或禁用 HTTP1.0（或更旧版本）请求的自动响应缓冲, 此缓冲机制主要用于 HTTP1.0 连接保持存活, 因为 HTTP1.1 以前的版本在请求响应后会关闭连接.
如果设置 Content-Length 响应头, 会关闭响应缓冲区.