init_by_lua里面能不能 ngx.timer.at呀？

bsch1983 · 2013-11-29T17:20:51+00:00

Hello! On Thu, Nov 28, 2013 at 8:18 PM, Lance wrote: > 附件中是我们最近优化应用&#...

init_by_lua里面能不能 ngx.timer.at呀？

bsch1983

init_by_lua '

local function timer(premature, a, b)

ngx.log(ngx.DEBUG, ngx.localtime())

end

ngx.log(ngx.DEBUG, "create xxx")

local ok, err = ngx.timer.at(1, timer, 1, 1)

--if not ok then

-- ngx.log(ngx.ERR, "failed to create timer: ", err)

-- return

--end

这个代码老是报错，不知道为啥，是不是ngx.timer.at不能用在init_by_lua上面呀？还是应该如何做？或者是我的bug？

我现在的项目需要访问第三方服务器，并且需要一直跟那个服务器保持连接，通讯协议里面规定得定时发心跳包来保持。

第三方服务器的响应是异步的，也就是，你send后，会马上给你返回，但是结果不是立即给你的，send的结果，是recv得到的数据，通过ID(send的包里面带的)来标识对应的是哪个send的结果。

我原计划是在init_by_lua里面，开辟两个timer，一个timer负责定时发送心跳包，另外一个timer负责recv结果的，在location里面，导出一个接口，让客户端调用，我拿到客户端的数据后，构造出第三方服务器的数据包发送。

但是现在上面的demo出问题了，不知道该咋搞。求指点

另外，该功能，该咋写比较合适。

agentzh

Hello!

2013/11/29 Fei Liang:
>
> 这个代码老是报错，不知道为啥，是不是ngx.timer.at不能用在init_by_lua上面呀？

init_by_lua 运行在 nginx master 进程加载配置的时候，发生在 nginx fork 出实际干活的各个 worker 进程的时间点之前。

我觉得未来即将实现的 init_worker_by_lua 配置指令最符合你这里的需求。

眼下有一种折衷的实现办法，即在每个 nginx worker
进程服务第一个请求时创建你的无限重复的定时器。你可以把是否已经创建定时器的状态放在你自己的某一个 Lua 模块里面，因为 Lua
模块级别的变量是当前 worker 进程共享的，见

  https://github.com/chaoslawful/lua-nginx-module#data-sharing-within-an-nginx-worker

进一步地，如果你希望你所有的 worker 进程只有一个定时器实际向后端保持心跳，可以考虑使用 lua-resty-lock 这个可以跨越
worker 进程的非阻塞的同步锁：

  https://github.com/agentzh/lua-resty-lock#readme

一般地，当你需要跨域多个 worker 进程传递和共享数据或状态时，应当使用 ngx_lua 的共享内存字典：

  https://github.com/chaoslawful/lua-nginx-module#lua_shared_dict

比如上面的 lua-resty-lock 库在底层就是基于这个共享内存字典服务。

Regards,
-agentzh

hxj137

agentzh

目前来说,想做一些唯一执行的计划任务只能通过 init_worker_by_lua + ngx.timer.at 创建多个 ,

然后通过resty.lock 来保证唯一性来实现是吧?

在 2013年11月30日星期六 UTC+8上午5:12:38，agentzh写道：

Hello!

2013/11/29 Fei Liang:
>
> 这个代码老是报错，不知道为啥，是不是ngx.timer.at不能用在init_by_lua上面呀？

init_by_lua 运行在 nginx master 进程加载配置的时候，发生在 nginx fork 出实际干活的各个 worker 进程的时间点之前。

我觉得未来即将实现的 init_worker_by_lua 配置指令最符合你这里的需求。

眼下有一种折衷的实现办法，即在每个 nginx worker
进程服务第一个请求时创建你的无限重复的定时器。你可以把是否已经创建定时器的状态放在你自己的某一个 Lua 模块里面，因为 Lua
模块级别的变量是当前 worker 进程共享的，见

https://github.com/chaoslawful/lua-nginx-module#data-sharing-within-an-nginx-worker

进一步地，如果你希望你所有的 worker 进程只有一个定时器实际向后端保持心跳，可以考虑使用 lua-resty-lock 这个可以跨越
worker 进程的非阻塞的同步锁：

https://github.com/agentzh/lua-resty-lock#readme

一般地，当你需要跨域多个 worker 进程传递和共享数据或状态时，应当使用 ngx_lua 的共享内存字典：

https://github.com/chaoslawful/lua-nginx-module#lua_shared_dict

比如上面的 lua-resty-lock 库在底层就是基于这个共享内存字典服务。

Regards,
-agentzh

agentzh

Hello!

2015-03-11 0:41 GMT-07:00  <hx...@gmail.com>:
>    目前来说,想做一些唯一执行的计划任务 只能通过   init_worker_by_lua + ngx.timer.at 创建多个 ,
>    然后通过resty.lock 来保证唯一性 来实现 是吧?
>

其实也可以使用 init_by_lua + 使用阻塞 IO 的第三方库（如果你需要作 IO 的话）。

cosocket API 在 init_by_lua 中的支持打算在近期实现一下。

Regards,
-agentzh

hxj137

那太好了, 另外如果 ngx.timer.at 也能运行在 init_by_lua 就好了

(当然我没从根本上了解过ngx,这也许是不行的)

总能看到你的回复真好~~ 祝福亦春健康快乐啊~~

在 2015年3月12日星期四 UTC+8上午5:24:38，agentzh写道：

Hello!

2015-03-11 0:41 GMT-07:00 <hxj...@gmail.com>:
> 目前来说,想做一些唯一执行的计划任务只能通过 init_worker_by_lua + ngx.timer.at 创建多个 ,
> 然后通过resty.lock 来保证唯一性来实现是吧?
>

其实也可以使用 init_by_lua + 使用阻塞 IO 的第三方库（如果你需要作 IO 的话）。

cosocket API 在 init_by_lua 中的支持打算在近期实现一下。

Regards,
-agentzh

agentzh

Hello!

2015-03-11 21:24 GMT-07:00  <hx...@gmail.com>:
> 那太好了, 另外 如果 ngx.timer.at 也能运行在 init_by_lua 就好了
> (当然我没从根本上了解过ngx,这也许是不行的)
>

在 init_by_lua 上下文中创建 timer 没有多少实际价值，因为 nginx master 进程不同于 worker
进程，并不能也不宜做太多的事情。

Regards,
-agentzh

hxj137

恩, 想了一下是这样的

还有个问题

不同的 worker process 中是单独的lua vm

那么例如 ngx.* 的值是共享的还是每个vm 独有复制于master的

比如我在某个worker process中调用了ngx.update_time()

能够保证别的worker process 中调用的 ngx.now() 也是得到了更新的值么?

在 2015年3月12日星期四 UTC+8下午12:39:29，agentzh写道：

Hello!

2015-03-11 21:24 GMT-07:00 <hxj...@gmail.com>:
> 那太好了, 另外如果 ngx.timer.at 也能运行在 init_by_lua 就好了
> (当然我没从根本上了解过ngx,这也许是不行的)
>

在 init_by_lua 上下文中创建 timer 没有多少实际价值，因为 nginx master 进程不同于 worker
进程，并不能也不宜做太多的事情。

Regards,
-agentzh

doujiang24

在 2015年3月13日下午1:42， <hx...@gmail.com>写道：

恩, 想了一下是这样的
还有个问题
不同的 worker process 中是单独的lua vm
那么例如 ngx.* 的值是共享的还是每个vm 独有复制于master的

比如我在某个worker process中调用了ngx.update_time()
能够保证别的worker process 中调用的 ngx.now() 也是得到了更新的值么?

不是

每个 worker 都是独立的进程，一般情况都不会共享数据，ngx.update_time只是更新了本进程内的缓存时间

https://github.com/nginx/nginx/blob/aa248e453fd0df9623d5da0f13727049e69e503d/src/core/ngx_times.c#L78

在 2015年3月12日星期四 UTC+8下午12:39:29，agentzh写道：
Hello!

2015-03-11 21:24 GMT-07:00 <hxj...@gmail.com>:
> 那太好了, 另外如果 ngx.timer.at 也能运行在 init_by_lua 就好了
> (当然我没从根本上了解过ngx,这也许是不行的)
>

在 init_by_lua 上下文中创建 timer 没有多少实际价值，因为 nginx master 进程不同于 worker
进程，并不能也不宜做太多的事情。

Regards,
-agentzh

--

mixiaojiong

您好，我近期有个场景。需要一个链接轮询后端一个接口，返回的数据存储在共享内存中，我想请问一下，我可不可以用cosocket 在init_by_lua中做呢？有一个问题就是因为init_by_lua中不支持ngx.timer.at，那么我的cosocket就必须是长连接么？

在 2015年3月12日星期四 UTC+8上午5:24:38，agentzh写道：

Hello!

2015-03-11 0:41 GMT-07:00 <hxj...@gmail.com>:
> 目前来说,想做一些唯一执行的计划任务只能通过 init_worker_by_lua + ngx.timer.at 创建多个 ,
> 然后通过resty.lock 来保证唯一性来实现是吧?
>

其实也可以使用 init_by_lua + 使用阻塞 IO 的第三方库（如果你需要作 IO 的话）。

cosocket API 在 init_by_lua 中的支持打算在近期实现一下。

Regards,
-agentzh

doujiang24

hello，

目前 cosocket 并不能用在 init_by_lua

你需要的是 init_worker_by_lua + ngx.timer.at

在 2016年4月5日上午7:35，赵睿 <mixia...@gmail.com>写道：

您好，我近期有个场景。需要一个链接轮询后端一个接口，返回的数据存储在共享内存中，我想请问一下，我可不可以用cosocket 在init_by_lua中做呢？有一个问题就是因为init_by_lua中不支持ngx.timer.at，那么我的cosocket就必须是长连接么？

在 2015年3月12日星期四 UTC+8上午5:24:38，agentzh写道：
Hello!

2015-03-11 0:41 GMT-07:00 <hxj...@gmail.com>:
> 目前来说,想做一些唯一执行的计划任务只能通过 init_worker_by_lua + ngx.timer.at 创建多个 ,
> 然后通过resty.lock 来保证唯一性来实现是吧?
>

其实也可以使用 init_by_lua + 使用阻塞 IO 的第三方库（如果你需要作 IO 的话）。

cosocket API 在 init_by_lua 中的支持打算在近期实现一下。

Regards,
-agentzh

--

wanhailong07

看起来init_worker_by_lua中不允许使用resty.lock，因为取锁的时候用到了sleep。

stack traceback:

[C]: in function 'sleep'

/usr/local/Cellar/openresty/1.11.2.3/lualib/resty/lock.lua:150: in function 'lock'

init_worker_by_lua:13: in main chunk

2017/06/16 15:31:27 [error] 56688#1719984: init_worker_by_lua error: /usr/local/Cellar/openresty/1.11.2.3/lualib/resty/lock.lua:150: API disabled in the context of init_worker_by_lua*

On Wednesday, March 11, 2015 at 3:41:03 PM UTC+8, hxj...@gmail.com wrote:

hi
agentzh
目前来说,想做一些唯一执行的计划任务只能通过 init_worker_by_lua + ngx.timer.at 创建多个 ,
然后通过resty.lock 来保证唯一性来实现是吧?

在 2013年11月30日星期六 UTC+8上午5:12:38，agentzh写道：
Hello!

2013/11/29 Fei Liang:
>
> 这个代码老是报错，不知道为啥，是不是ngx.timer.at不能用在init_by_lua上面呀？

init_by_lua 运行在 nginx master 进程加载配置的时候，发生在 nginx fork 出实际干活的各个 worker 进程的时间点之前。

我觉得未来即将实现的 init_worker_by_lua 配置指令最符合你这里的需求。

眼下有一种折衷的实现办法，即在每个 nginx worker
进程服务第一个请求时创建你的无限重复的定时器。你可以把是否已经创建定时器的状态放在你自己的某一个 Lua 模块里面，因为 Lua
模块级别的变量是当前 worker 进程共享的，见

https://github.com/chaoslawful/lua-nginx-module#data-sharing-within-an-nginx-worker

进一步地，如果你希望你所有的 worker 进程只有一个定时器实际向后端保持心跳，可以考虑使用 lua-resty-lock 这个可以跨越
worker 进程的非阻塞的同步锁：

https://github.com/agentzh/lua-resty-lock#readme

一般地，当你需要跨域多个 worker 进程传递和共享数据或状态时，应当使用 ngx_lua 的共享内存字典：

https://github.com/chaoslawful/lua-nginx-module#lua_shared_dict

比如上面的 lua-resty-lock 库在底层就是基于这个共享内存字典服务。

Regards,
-agentzh

zchao1995

恩，不过 sleep 时间为 0 是可以的（立刻返回）

On Friday, June 16, 2017 at 3:46:35 PM UTC+8, wanhai...@gmail.com wrote:

看起来init_worker_by_lua中不允许使用resty.lock，因为取锁的时候用到了sleep。
stack traceback:
[C]: in function 'sleep'
/usr/local/Cellar/openresty/1.11.2.3/lualib/resty/lock.lua:150: in function 'lock'
init_worker_by_lua:13: in main chunk
2017/06/16 15:31:27 [error] 56688#1719984: init_worker_by_lua error: /usr/local/Cellar/openresty/1.11.2.3/lualib/resty/lock.lua:150: API disabled in the context of init_worker_by_lua*

On Wednesday, March 11, 2015 at 3:41:03 PM UTC+8, hxj...@gmail.com wrote:
hi
agentzh
目前来说,想做一些唯一执行的计划任务只能通过 init_worker_by_lua + ngx.timer.at 创建多个 ,
然后通过resty.lock 来保证唯一性来实现是吧?

在 2013年11月30日星期六 UTC+8上午5:12:38，agentzh写道：
Hello!

2013/11/29 Fei Liang:
>
> 这个代码老是报错，不知道为啥，是不是ngx.timer.at不能用在init_by_lua上面呀？

init_by_lua 运行在 nginx master 进程加载配置的时候，发生在 nginx fork 出实际干活的各个 worker 进程的时间点之前。

我觉得未来即将实现的 init_worker_by_lua 配置指令最符合你这里的需求。

眼下有一种折衷的实现办法，即在每个 nginx worker
进程服务第一个请求时创建你的无限重复的定时器。你可以把是否已经创建定时器的状态放在你自己的某一个 Lua 模块里面，因为 Lua
模块级别的变量是当前 worker 进程共享的，见

https://github.com/chaoslawful/lua-nginx-module#data-sharing-within-an-nginx-worker

进一步地，如果你希望你所有的 worker 进程只有一个定时器实际向后端保持心跳，可以考虑使用 lua-resty-lock 这个可以跨越
worker 进程的非阻塞的同步锁：

https://github.com/agentzh/lua-resty-lock#readme

一般地，当你需要跨域多个 worker 进程传递和共享数据或状态时，应当使用 ngx_lua 的共享内存字典：

https://github.com/chaoslawful/lua-nginx-module#lua_shared_dict

比如上面的 lua-resty-lock 库在底层就是基于这个共享内存字典服务。

Regards,
-agentzh