使用websocket做长连接，当客户端断开连接，nginx server感知不到

leejia1989 · 2016-06-25T12:22:14+00:00

(Client A) --->【OpenResty] --->(System A)如上所示：Client A是我们客户的&#x7CFB...

使用websocket做长连接，当客户端断开连接，nginx server感知不到

leejia1989

求大神帮忙。

问题描述：使用如下代码，当client断开连接的时候，nginx能感知到。但是，把websocket sever那一块代码注释给打开，client断开连接的话，nginx server感知不到，也不会有任何错误日志。

location /t {

lua_check_client_abort on;

access_by_lua '

local ok, err = ngx.on_abort(function ()

ngx.log(ngx.ERR, "on abort called")

ngx.exit(499)

end)

if not ok then

ngx.log(ngx.ERR, "cannot set on_abort: " .. err)

end

--local server = require "resty.websocket.server"

--local wb, err = server:new{

-- timeout = 5000, -- in milliseconds

-- max_payload_len = 65535,

--}

--if not wb then

-- ngx.log(ngx.ERR, "failed to new websocket: ", err)

-- return ngx.exit(444)

--end

ngx.sleep(10)

content_by_lua return;

}

doujiang24

Hello

2016-06-25 12:22 GMT+08:00 <leej...@gmail.com>:

ngx.sleep(10)

你把这个 ngx.sleep 换成 wb:recv_frame ?

';
content_by_lua return;
}

--

leejia1989

Hi,德江老师

刚把ngx.sleep()换成了wb:recv_frame也捕获不到。

我这边的场景是：

一个websocket连接到nginx这里，我起一个receive客户端的轻线程和一个从后端读取数据send给客户端的轻线程。当client断开连接之后，我想要捕获到这个信息，然后做一些操作。现在就是加了websocket server这一块代码在主线程之后，一直捕获不到client断开连接的信息。

类似线上代码：

location /t {

lua_check_client_abort on;

access_by_lua '

local ok, err = ngx.on_abort(function ()

ngx.log(ngx.ERR, "on abort called")

ngx.exit(499)

end)

if not ok then

ngx.log(ngx.ERR, "cannot set on_abort: " .. err)

end

local server = require "resty.websocket.server"

local wb, err = server:new{

timeout = 5000, -- in milliseconds

max_payload_len = 65535,

}

if not wb then

ngx.log(ngx.ERR, "failed to new websocket: ", err)

return ngx.exit(444)

end

--ngx.sleep(10)

ngx.thread.spawn(websocket_receive_fun, wb)

ngx.thread.spawn(websocket_send_fun, wb)

content_by_lua return;

}

我是了解到您那边的长连接也是类似的场景，所以向您请教，您那边是怎么捕获client断开连接的。

thx!

在 2016年6月25日下午9:22，DeJiang Zhu <douj...@gmail.com>写道：

Hello

2016-06-25 12:22 GMT+08:00 <leej...@gmail.com>:

ngx.sleep(10)

你把这个 ngx.sleep 换成 wb:recv_frame ?

';
content_by_lua return;
}

--

--

doujiang24

Hello

在 2016年6月27日上午11:19，李圣佳 <leej...@gmail.com>写道：

local ok, err = ngx.on_abort(function ()
ngx.log(ngx.ERR, "on abort called")
ngx.exit(499)
end)

这里并不需要了

--ngx.sleep(10)
ngx.thread.spawn(websocket_receive_fun, wb)

在客户端主动断开的时候， websocket_receive_fun 应该会返回错误的

ngx.thread.spawn(websocket_send_fun, wb)

';
content_by_lua return;
}

我是了解到您那边的长连接也是类似的场景，所以向您请教，您那边是怎么捕获client断开连接的。

thx!

在 2016年6月25日下午9:22，DeJiang Zhu <douj...@gmail.com>写道：
Hello

2016-06-25 12:22 GMT+08:00 <leej...@gmail.com>:

ngx.sleep(10)

你把这个 ngx.sleep 换成 wb:recv_frame ?

';
content_by_lua return;
}

--

--

--

leejia1989

是的，当client断开连接的时候，websocket receive总会报一个错误。我现在就是通过判断这个错误来断定client是否断开连接，不知道这种办法是否科学，也不知道为什么on_abort不起作用。那我就先用这个办法来判断吧，多谢德江老师帮忙！

代码如下：

local data, typ, err = wb:recv_frame()

if not data then

ngx.log(ngx.ERR, "failed to receive a frame: ", err)

if err == "fatal error already happened" then

ngx.log(ngx.ERR, "client already disconnceted")

end

在 2016年6月27日下午10:34，DeJiang Zhu <douj...@gmail.com>写道：

Hello

在 2016年6月27日上午11:19，李圣佳 <leej...@gmail.com>写道：

local ok, err = ngx.on_abort(function ()
ngx.log(ngx.ERR, "on abort called")
ngx.exit(499)
end)

这里并不需要了

--ngx.sleep(10)
ngx.thread.spawn(websocket_receive_fun, wb)

在客户端主动断开的时候， websocket_receive_fun 应该会返回错误的

ngx.thread.spawn(websocket_send_fun, wb)

';
content_by_lua return;
}

我是了解到您那边的长连接也是类似的场景，所以向您请教，您那边是怎么捕获client断开连接的。

thx!

在 2016年6月25日下午9:22，DeJiang Zhu <douj...@gmail.com>写道：
Hello

2016-06-25 12:22 GMT+08:00 <leej...@gmail.com>:

ngx.sleep(10)

你把这个 ngx.sleep 换成 wb:recv_frame ?

';
content_by_lua return;
}

--

--

--

--

doujiang24

Hello

在 2016年6月28日上午10:48，李圣佳 <leej...@gmail.com>写道：

Hi
是的，当client断开连接的时候，websocket receive总会报一个错误。我现在就是通过判断这个错误来断定client是否断开连接，不知道这种办法是否科学

这才是科学办法

也不知道为什么on_abort不起作用。

lua-resty-websocket 底层使用了 ngx.req.socket 全面接管了当前 socket 的读写

on_abort 一般用于非这种场景的

那我就先用这个办法来判断吧，多谢德江老师帮忙！

代码如下：
local data, typ, err = wb:recv_frame()
if not data then
ngx.log(ngx.ERR, "failed to receive a frame: ", err)
if err == "fatal error already happened" then

你这个判断不是特别严谨

理论上只要不是 timeout 的错误都可以认为连接已经坏了

你可以通过 self.fatal 来判断是否连接坏了，具体你可以看看源码：

https://github.com/openresty/lua-resty-websocket/blob/master/lib/resty/websocket/server.lua#L140

另外更加严谨的设计是：

让客户端定时发个 ping 包

ngx.log(ngx.ERR, "client already disconnceted")
end
end

在 2016年6月27日下午10:34，DeJiang Zhu <douj...@gmail.com>写道：
Hello

在 2016年6月27日上午11:19，李圣佳 <leej...@gmail.com>写道：

local ok, err = ngx.on_abort(function ()
ngx.log(ngx.ERR, "on abort called")
ngx.exit(499)
end)

这里并不需要了

--ngx.sleep(10)
ngx.thread.spawn(websocket_receive_fun, wb)

在客户端主动断开的时候， websocket_receive_fun 应该会返回错误的

ngx.thread.spawn(websocket_send_fun, wb)

';
content_by_lua return;
}

我是了解到您那边的长连接也是类似的场景，所以向您请教，您那边是怎么捕获client断开连接的。

thx!

在 2016年6月25日下午9:22，DeJiang Zhu <douj...@gmail.com>写道：
Hello

2016-06-25 12:22 GMT+08:00 <leej...@gmail.com>:

ngx.sleep(10)

你把这个 ngx.sleep 换成 wb:recv_frame ?

';
content_by_lua return;
}

--

--

--

--

--

leejia1989

Hi：

好的，我看看！多谢德江老师百忙之中指导，非常感谢！

在 2016年6月29日上午10:08，DeJiang Zhu <douj...@gmail.com>写道：

Hello

在 2016年6月28日上午10:48，李圣佳 <leej...@gmail.com>写道：
Hi
是的，当client断开连接的时候，websocket receive总会报一个错误。我现在就是通过判断这个错误来断定client是否断开连接，不知道这种办法是否科学

这才是科学办法

也不知道为什么on_abort不起作用。

lua-resty-websocket 底层使用了 ngx.req.socket 全面接管了当前 socket 的读写
on_abort 一般用于非这种场景的

那我就先用这个办法来判断吧，多谢德江老师帮忙！

代码如下：
local data, typ, err = wb:recv_frame()
if not data then
ngx.log(ngx.ERR, "failed to receive a frame: ", err)
if err == "fatal error already happened" then

你这个判断不是特别严谨
理论上只要不是 timeout 的错误都可以认为连接已经坏了

你可以通过 self.fatal 来判断是否连接坏了，具体你可以看看源码：
https://github.com/openresty/lua-resty-websocket/blob/master/lib/resty/websocket/server.lua#L140

另外更加严谨的设计是：
让客户端定时发个 ping 包

ngx.log(ngx.ERR, "client already disconnceted")
end
end

在 2016年6月27日下午10:34，DeJiang Zhu <douj...@gmail.com>写道：
Hello

在 2016年6月27日上午11:19，李圣佳 <leej...@gmail.com>写道：

local ok, err = ngx.on_abort(function ()
ngx.log(ngx.ERR, "on abort called")
ngx.exit(499)
end)

这里并不需要了

--ngx.sleep(10)
ngx.thread.spawn(websocket_receive_fun, wb)

在客户端主动断开的时候， websocket_receive_fun 应该会返回错误的

ngx.thread.spawn(websocket_send_fun, wb)

';
content_by_lua return;
}

我是了解到您那边的长连接也是类似的场景，所以向您请教，您那边是怎么捕获client断开连接的。

thx!

在 2016年6月25日下午9:22，DeJiang Zhu <douj...@gmail.com>写道：
Hello

2016-06-25 12:22 GMT+08:00 <leej...@gmail.com>:

ngx.sleep(10)

你把这个 ngx.sleep 换成 wb:recv_frame ?

';
content_by_lua return;
}

--

--

--

--

--

--

leejia1989

@德江老师

再请教一个问题：

当websocket client请求过来之后，我这边用ngx.thread.spawn起了两个轻线程，一个轻线程负责从client读数据，另一个负责向client写入数据。看您之前的文章说正好同时向这个链接写和读的话会有问题，您是怎么解决这个问题的？或者说我这种处理websocket 读和写的用两个轻线程的方式是否合理？

thx！

在 2016年6月29日上午10:29，李圣佳 <leej...@gmail.com>写道：

Hi：
好的，我看看！多谢德江老师百忙之中指导，非常感谢！

在 2016年6月29日上午10:08，DeJiang Zhu <douj...@gmail.com>写道：
Hello

在 2016年6月28日上午10:48，李圣佳 <leej...@gmail.com>写道：
Hi
是的，当client断开连接的时候，websocket receive总会报一个错误。我现在就是通过判断这个错误来断定client是否断开连接，不知道这种办法是否科学

这才是科学办法

也不知道为什么on_abort不起作用。

lua-resty-websocket 底层使用了 ngx.req.socket 全面接管了当前 socket 的读写
on_abort 一般用于非这种场景的

那我就先用这个办法来判断吧，多谢德江老师帮忙！

代码如下：
local data, typ, err = wb:recv_frame()
if not data then
ngx.log(ngx.ERR, "failed to receive a frame: ", err)
if err == "fatal error already happened" then

你这个判断不是特别严谨
理论上只要不是 timeout 的错误都可以认为连接已经坏了

你可以通过 self.fatal 来判断是否连接坏了，具体你可以看看源码：
https://github.com/openresty/lua-resty-websocket/blob/master/lib/resty/websocket/server.lua#L140

另外更加严谨的设计是：
让客户端定时发个 ping 包

ngx.log(ngx.ERR, "client already disconnceted")
end
end

在 2016年6月27日下午10:34，DeJiang Zhu <douj...@gmail.com>写道：
Hello

在 2016年6月27日上午11:19，李圣佳 <leej...@gmail.com>写道：

local ok, err = ngx.on_abort(function ()
ngx.log(ngx.ERR, "on abort called")
ngx.exit(499)
end)

这里并不需要了

--ngx.sleep(10)
ngx.thread.spawn(websocket_receive_fun, wb)

在客户端主动断开的时候， websocket_receive_fun 应该会返回错误的

ngx.thread.spawn(websocket_send_fun, wb)

';
content_by_lua return;
}

我是了解到您那边的长连接也是类似的场景，所以向您请教，您那边是怎么捕获client断开连接的。

thx!

在 2016年6月25日下午9:22，DeJiang Zhu <douj...@gmail.com>写道：
Hello

2016-06-25 12:22 GMT+08:00 <leej...@gmail.com>:

ngx.sleep(10)

你把这个 ngx.sleep 换成 wb:recv_frame ?

';
content_by_lua return;
}

--

--

--

--

--

--

doujiang24

Hello

在 2016年7月13日下午6:51，李圣佳 <leej...@gmail.com>写道：

当websocket client请求过来之后，我这边用ngx.thread.spawn起了两个轻线程，一个轻线程负责从client读数据，另一个负责向client写入数据。看您之前的文章说正好同时向这个链接写和读的话会有问题，您是怎么解决这个问题的？

我的解决办法比较简单，有一个小小的锁实现来毕竟同时写

或者说我这种处理websocket 读和写的用两个轻线程的方式是否合理？

这个看你的业务需要，如果你并不需要那个写的线程，那就只要一个线程好了

单线程是不可能有读写冲突的

thx！

在 2016年6月29日上午10:29，李圣佳 <leej...@gmail.com>写道：
Hi：
好的，我看看！多谢德江老师百忙之中指导，非常感谢！

在 2016年6月29日上午10:08，DeJiang Zhu <douj...@gmail.com>写道：
Hello

在 2016年6月28日上午10:48，李圣佳 <leej...@gmail.com>写道：
Hi
是的，当client断开连接的时候，websocket receive总会报一个错误。我现在就是通过判断这个错误来断定client是否断开连接，不知道这种办法是否科学

这才是科学办法

也不知道为什么on_abort不起作用。

lua-resty-websocket 底层使用了 ngx.req.socket 全面接管了当前 socket 的读写
on_abort 一般用于非这种场景的

那我就先用这个办法来判断吧，多谢德江老师帮忙！

代码如下：
local data, typ, err = wb:recv_frame()
if not data then
ngx.log(ngx.ERR, "failed to receive a frame: ", err)
if err == "fatal error already happened" then

你这个判断不是特别严谨
理论上只要不是 timeout 的错误都可以认为连接已经坏了

你可以通过 self.fatal 来判断是否连接坏了，具体你可以看看源码：
https://github.com/openresty/lua-resty-websocket/blob/master/lib/resty/websocket/server.lua#L140

另外更加严谨的设计是：
让客户端定时发个 ping 包

ngx.log(ngx.ERR, "client already disconnceted")
end
end

在 2016年6月27日下午10:34，DeJiang Zhu <douj...@gmail.com>写道：
Hello

在 2016年6月27日上午11:19，李圣佳 <leej...@gmail.com>写道：

local ok, err = ngx.on_abort(function ()
ngx.log(ngx.ERR, "on abort called")
ngx.exit(499)
end)

这里并不需要了

--ngx.sleep(10)
ngx.thread.spawn(websocket_receive_fun, wb)

在客户端主动断开的时候， websocket_receive_fun 应该会返回错误的

ngx.thread.spawn(websocket_send_fun, wb)

';
content_by_lua return;
}

我是了解到您那边的长连接也是类似的场景，所以向您请教，您那边是怎么捕获client断开连接的。

thx!

在 2016年6月25日下午9:22，DeJiang Zhu <douj...@gmail.com>写道：
Hello

2016-06-25 12:22 GMT+08:00 <leej...@gmail.com>:

ngx.sleep(10)

你把这个 ngx.sleep 换成 wb:recv_frame ?

';
content_by_lua return;
}

--

--

--

--

--

--

--

sumory.wu

对于一个websocket对象，ngx.thread.spawn起了两个轻线程，一个写一个读，也不能同时读写是吗？还得必须加锁？

在 2016年7月13日星期三 UTC+8下午10:40:02，doujiang写道：

Hello

在 2016年7月13日下午6:51，李圣佳 <leeji...@gmail.com>写道：
当websocket client请求过来之后，我这边用ngx.thread.spawn起了两个轻线程，一个轻线程负责从client读数据，另一个负责向client写入数据。看您之前的文章说正好同时向这个链接写和读的话会有问题，您是怎么解决这个问题的？

我的解决办法比较简单，有一个小小的锁实现来毕竟同时写

或者说我这种处理websocket 读和写的用两个轻线程的方式是否合理？

这个看你的业务需要，如果你并不需要那个写的线程，那就只要一个线程好了
单线程是不可能有读写冲突的

thx！

在 2016年6月29日上午10:29，李圣佳 <leeji...@gmail.com>写道：
Hi：
好的，我看看！多谢德江老师百忙之中指导，非常感谢！

在 2016年6月29日上午10:08，DeJiang Zhu <douji...@gmail.com>写道：
Hello

在 2016年6月28日上午10:48，李圣佳 <leeji...@gmail.com>写道：
Hi
是的，当client断开连接的时候，websocket receive总会报一个错误。我现在就是通过判断这个错误来断定client是否断开连接，不知道这种办法是否科学

这才是科学办法

也不知道为什么on_abort不起作用。

lua-resty-websocket 底层使用了 ngx.req.socket 全面接管了当前 socket 的读写
on_abort 一般用于非这种场景的

那我就先用这个办法来判断吧，多谢德江老师帮忙！

代码如下：
local data, typ, err = wb:recv_frame()
if not data then
ngx.log(ngx.ERR, "failed to receive a frame: ", err)
if err == "fatal error already happened" then

你这个判断不是特别严谨
理论上只要不是 timeout 的错误都可以认为连接已经坏了

你可以通过 self.fatal 来判断是否连接坏了，具体你可以看看源码：
https://github.com/openresty/lua-resty-websocket/blob/master/lib/resty/websocket/server.lua#L140

另外更加严谨的设计是：
让客户端定时发个 ping 包

ngx.log(ngx.ERR, "client already disconnceted")
end
end

在 2016年6月27日下午10:34，DeJiang Zhu <douji...@gmail.com>写道：
Hello

在 2016年6月27日上午11:19，李圣佳 <leeji...@gmail.com>写道：

local ok, err = ngx.on_abort(function ()
ngx.log(ngx.ERR, "on abort called")
ngx.exit(499)
end)

这里并不需要了

--ngx.sleep(10)
ngx.thread.spawn(websocket_receive_fun, wb)

在客户端主动断开的时候， websocket_receive_fun 应该会返回错误的

ngx.thread.spawn(websocket_send_fun, wb)

';
content_by_lua return;
}

我是了解到您那边的长连接也是类似的场景，所以向您请教，您那边是怎么捕获client断开连接的。

thx!

在 2016年6月25日下午9:22，DeJiang Zhu <douji...@gmail.com>写道：
Hello

2016-06-25 12:22 GMT+08:00 <leeji...@gmail.com>:

ngx.sleep(10)

你把这个 ngx.sleep 换成 wb:recv_frame ?

';
content_by_lua return;
}

--

--

--

--

--

--

--

doujiang24

Hello

在 2016年8月22日下午12:20，sumory wu <sumo...@gmail.com>写道：

对于一个websocket对象，ngx.thread.spawn起了两个轻线程，一个写一个读，也不能同时读写是吗？还得必须加锁？

并不是的，cosocket 是全双工，一个读一个写没有问题，不需要锁

我说的锁是指：有些时候我们两个线程都会有一些写的逻辑，这个时候才需要小锁

在 2016年7月13日星期三 UTC+8下午10:40:02，doujiang写道：
Hello

在 2016年7月13日下午6:51，李圣佳 <leeji...@gmail.com>写道：
当websocket client请求过来之后，我这边用ngx.thread.spawn起了两个轻线程，一个轻线程负责从client读数据，另一个负责向client写入数据。看您之前的文章说正好同时向这个链接写和读的话会有问题，您是怎么解决这个问题的？

我的解决办法比较简单，有一个小小的锁实现来毕竟同时写

或者说我这种处理websocket 读和写的用两个轻线程的方式是否合理？

这个看你的业务需要，如果你并不需要那个写的线程，那就只要一个线程好了
单线程是不可能有读写冲突的

thx！

在 2016年6月29日上午10:29，李圣佳 <leeji...@gmail.com>写道：
Hi：
好的，我看看！多谢德江老师百忙之中指导，非常感谢！

在 2016年6月29日上午10:08，DeJiang Zhu <douji...@gmail.com>写道：
Hello

在 2016年6月28日上午10:48，李圣佳 <leeji...@gmail.com>写道：
Hi
是的，当client断开连接的时候，websocket receive总会报一个错误。我现在就是通过判断这个错误来断定client是否断开连接，不知道这种办法是否科学

这才是科学办法

也不知道为什么on_abort不起作用。

lua-resty-websocket 底层使用了 ngx.req.socket 全面接管了当前 socket 的读写
on_abort 一般用于非这种场景的

那我就先用这个办法来判断吧，多谢德江老师帮忙！

代码如下：
local data, typ, err = wb:recv_frame()
if not data then
ngx.log(ngx.ERR, "failed to receive a frame: ", err)
if err == "fatal error already happened" then

你这个判断不是特别严谨
理论上只要不是 timeout 的错误都可以认为连接已经坏了

你可以通过 self.fatal 来判断是否连接坏了，具体你可以看看源码：
https://github.com/openresty/lua-resty-websocket/blob/master/lib/resty/websocket/server.lua#L140

另外更加严谨的设计是：
让客户端定时发个 ping 包

ngx.log(ngx.ERR, "client already disconnceted")
end
end

在 2016年6月27日下午10:34，DeJiang Zhu <douji...@gmail.com>写道：
Hello

在 2016年6月27日上午11:19，李圣佳 <leeji...@gmail.com>写道：

local ok, err = ngx.on_abort(function ()
ngx.log(ngx.ERR, "on abort called")
ngx.exit(499)
end)

这里并不需要了

--ngx.sleep(10)
ngx.thread.spawn(websocket_receive_fun, wb)

在客户端主动断开的时候， websocket_receive_fun 应该会返回错误的

ngx.thread.spawn(websocket_send_fun, wb)

';
content_by_lua return;
}

我是了解到您那边的长连接也是类似的场景，所以向您请教，您那边是怎么捕获client断开连接的。

thx!

在 2016年6月25日下午9:22，DeJiang Zhu <douji...@gmail.com>写道：
Hello

2016-06-25 12:22 GMT+08:00 <leeji...@gmail.com>:

ngx.sleep(10)

你把这个 ngx.sleep 换成 wb:recv_frame ?

';
content_by_lua return;
}

--

--

--

--

--

--

--

--