nginx_lua 扩展让 nginx 拥有可编程能力

公司使用 lighttpd 的比较多, 主要是接入层的一些工作，而且增加了一些很多自己的模块防火墙等等. 后来
nginx开始流行起来因为 lighttpd 和 nginx整体是实现方式比较类似(个人感觉nginx 借鉴了 lighttpd的实现方式)，
都使用了多进程异步非阻塞处理请求I/O和timer，对于静态文件服务使用sendfile系统调用. 作为静态文件server
和接入层来说 lighttpd 已经足够的快，所以用lighttpd 和 nginx没太大区别. 简单来说nginx 相对于lighttpd 没有
质的提高, 所以公司推广nginx 的动力不是太大.

nginx_lua 模块的推出使得 nginx 和 lighttpd 不在一个水平线上了. nginx_lua大大降低了nginx moudle开发的
门槛，使用lua 语言可以替代以前使用c开发nginx moudle的很多场景. 可以很方便的给nginx 增加功能，这点lighttpd
很难做到.

关于nginx_lua的介绍可以看看作者的一个演讲记录: 由Lua 粘合的Nginx生态环境 ,本文主要介绍lua socket
I/O特点。 根据nginx 工作方式的特点每Nginx工作进程使用一个Lua VM，工作进程内所有协程共享VM. 每一个
外部请求都由一个新的Lua协程处理, 协程之间数据隔离. 当Lua代码调用I/O操作接口时，若该操作无法立刻完成
(例如 recv 会引起阻塞)协程会保存当前状态, 由Nginx 继续处理其他请求, 相关数据I/O操作完成时resume相关协
程并继续运行。

location = /tcptest {
    content_by_lua '
		local sock = ngx.socket.tcp()
		sock:settimeout(1000)   
		local ok, err = sock:connect("127.0.0.1", 11211)
		if not ok then
   			ngx.say("failed to connect: ", err)
   			return
		end

		local bytes, err = sock:send("flush_allrn")
		if not bytes then
    		ngx.say("failed to send query: ", err)
    		return
		end
 
		local line, err = sock:receive()
		if not line then
    		ngx.say("failed to receive a line: ", err)
    		return
		end
 
		ngx.say("result: ", line)
    ';
}

上述例子中的 socket:receive()要等待对方数据返回的, nginx_lua 模块适配了 nginx.socket I/O操作，
nginx.socket的 I/O 操作都不会阻塞当前工作进程， nginx.socket 可以使用同步的方式实现异步I/O, 工作方式
上面说了一些，下面简单来分析一下:

1.  新的http请求执行到 lua 代码时会创建一个新的lua 协程

2.  当该lua 协程调用sock:receive()等函数时, 会有nginx.socket 来接管 I/O操作，nginx.socket 会yield当前协程，

     注册 I/O的回调到nginx事件循环中，继续Nginx的其他处理

3.  当收到数据时，Nginx获得到该事件调用回调，唤醒之前的协程继续处理

我们拿最简单的ngx.sleep 流程看一下nginx 的内部处理, 下面lua 代码针对该请求sleep 1秒钟， 并返回结果

location /sleep {
    content_by_lua_block {
        ngx.sleep(1)
        ngx.say("1s later..")
    }
}

Nginx lua 实现：

 * Copyright (C) Xiaozhe Wang (chaoslawful) * Copyright (C) Yichun Zhang (agentzh) */
 * Copyright (C) Xiaozhe Wang (chaoslawful)
 * Copyright (C) Yichun Zhang (agentzh)
 */



#define DDEBUG 0
#endif
#include "ddebug.h"


#include "ngx_http_lua_util.h"
#include "ngx_http_lua_sleep.h"
#include "ngx_http_lua_contentby.h"


static int (lua_State *L);
static void ngx_http_lua_sleep_handler(ngx_event_t *ev);
static void ngx_http_lua_sleep_cleanup(void *data);
static ngx_int_t ngx_http_lua_sleep_resume(ngx_http_request_t *r);


static int(lua_State *L){
(lua_State *L)

    int                          n;
    ngx_int_t                    delay; /* in msec */
    ngx_http_request_t          *r;
    ngx_http_lua_ctx_t          *ctx;
    ngx_http_lua_co_ctx_t       *coctx;

    n = lua_gettop(L);
    if (n != 1) {
        return luaL_error(L, "attempt to pass %d arguments, but accepted 1", n);
    }

    lua_pushlightuserdata(L, &ngx_http_lua_request_key);
    lua_rawget(L, LUA_GLOBALSINDEX);
    r = lua_touserdata(L, -1);
    lua_pop(L, 1);

    delay = luaL_checknumber(L, 1) * 1000;

    if (delay < 0) {
        return luaL_error(L, "invalid sleep duration "%d"", delay);
    }

    if (delay == 0) {
        ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
                       "lua sleep for 0ms");
        return 0;
    }

    ctx = ngx_http_get_module_ctx(r, ngx_http_lua_module);
    if (ctx == NULL) {
        return luaL_error(L, "no request ctx found");
    }

    coctx = ctx->cur_co_ctx;
    if (coctx == NULL) {
        return luaL_error(L, "no co ctx found");
    }

    coctx->data = r;
    // 指定 timer超时的回调函数  
    coctx->sleep.handler = ngx_http_lua_sleep_handler;
    coctx->sleep.data = coctx;
    coctx->sleep.log = r->connection->log;

    dd("adding timer with delay %lu ms, r:%.*s", (unsigned long) delay,
       (int) r->uri.len, r->uri.data);
    // 将timer 回调event 加入到 nginx timer 管理中  
    ngx_add_timer(&coctx->sleep, (ngx_msec_t) delay);

    coctx->cleanup = ngx_http_lua_sleep_cleanup;

    ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
                   "lua ready to sleep for %d ms", delay);
    // 保存当前协程上下文， 并返回到nginx主循环由nginx继续处理其他请求
    return lua_yield(L, 0);
}

// timer expired 触发的回调  
voidngx_http_lua_sleep_handler(ngx_event_t *ev){
ngx_http_lua_sleep_handler(ngx_event_t *ev)

    ngx_connection_t        *c;
    ngx_http_request_t      *r;
    ngx_http_lua_ctx_t      *ctx;
    ngx_http_log_ctx_t      *log_ctx;
    ngx_http_lua_co_ctx_t   *coctx;

    coctx = ev->data;

    r = coctx->data;
    c = r->connection;

    ctx = ngx_http_get_module_ctx(r, ngx_http_lua_module);

    if (ctx == NULL) {
        return;
    }

    log_ctx = c->log->data;
    log_ctx->current_request = r;

    coctx->cleanup = NULL;

    ngx_log_debug2(NGX_LOG_DEBUG_HTTP, c->log, 0,
                   "lua sleep timer expired: "%V?%V"", &r->uri, &r->args);

    ctx->cur_co_ctx = coctx;

    if (ctx->entered_content_phase) {
    	//恢复之前的 lua协程，继续处理  
        (void) ngx_http_lua_sleep_resume(r);

    } else {
        ctx->resume_handler = ngx_http_lua_sleep_resume;
        ngx_http_core_run_phases(r);
    }

    ngx_http_run_posted_requests(c);
}


voidngx_http_lua_inject_sleep_api(lua_State *L){
ngx_http_lua_inject_sleep_api(lua_State *L)

    lua_pushcfunction(L, ngx_http_lua_ngx_sleep);
    lua_setfield(L, -2, "sleep");
}


static voidngx_http_lua_sleep_cleanup(void *data){
ngx_http_lua_sleep_cleanup(void *data)

    ngx_http_lua_co_ctx_t          *coctx = data;

    if (coctx->sleep.timer_set) {
        dd("cleanup: deleting timer for ngx.sleep");

        ngx_del_timer(&coctx->sleep);
    }
}


static ngx_int_tngx_http_lua_sleep_resume(ngx_http_request_t *r){
ngx_http_lua_sleep_resume(ngx_http_request_t *r)

    ngx_connection_t            *c;
    ngx_int_t                    rc;
    ngx_http_lua_ctx_t          *ctx;
    ngx_http_lua_main_conf_t    *lmcf;

    ctx = ngx_http_get_module_ctx(r, ngx_http_lua_module);
    if (ctx == NULL) {
        return NGX_ERROR;
    }

    ctx->resume_handler = ngx_http_lua_wev_handler;

    lmcf = ngx_http_get_module_main_conf(r, ngx_http_lua_module);

    c = r->connection;

    rc = ngx_http_lua_run_thread(lmcf->lua, r, ctx, 0);

    ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
                   "lua run thread returned %d", rc);

    if (rc == NGX_AGAIN) {
        return ngx_http_lua_run_posted_threads(c, lmcf->lua, r, ctx);
    }

    if (rc == NGX_DONE) {
        ngx_http_finalize_request(r, NGX_DONE);
        return ngx_http_lua_run_posted_threads(c, lmcf->lua, r, ctx);
    }

    if (ctx->entered_content_phase) {
        ngx_http_finalize_request(r, rc);
        return NGX_DONE;
    }

    return rc;
}

转载请注明出处，谢谢。。