skynet实践（8）-接入websocket

我从开源项目（https://github.com/lipp/lua-websockets，这里我们简称LWS）中抽出了websocket的部分处理，步骤如下：

1）首先是解决LWS的几个依赖问题。LWS在握手阶段的base64编解码使用了luasocket中的mime，因此在3rd文件夹中建立mime文件夹，将mime.h和mime.c文件放进去，修改skynet的Makefile文件，作为一个单独的动态库编译：

 LUA_CLIB = skynet \
   client \
   bson md5 sproto lpeg mime

 $(LUA_CLIB_PATH)/mime.so : 3rd/mime/mime.c | $(LUA_CLIB_PATH)
     $(CC) $(CFLAGS) $(SHARED) -I3rd/mime $^ -o $@ 

在tools.lua中引用了mime，由于我们只用了C文件，因此修改require "mime" 为： require "mime.core" 。

对于luabitop，skynet自带的lua5.3源码已经支持（在lbitlib.c文件中），但是默认是关闭的，修改lua5.3的Makefile，增加LUA_COMPAT_BITLIB宏并重新编译：

 MYCFLAGS=-I../../skynet-src -g -DLUA_COMPAT_BITLIB

这样在bit.lua中对bit32就能正确引用了。

2）下一步则是在skynet端侦听tcp连接：

 local skynet = require "skynet"
 local socket = require "skynet.socket"

 skynet.start(function()
     local id = socket.listen("0.0.0.0", )
     skynet.error("web server listen on web port 8001")

     socket.start(id, function(id, addr)
         local agent = skynet.newservice("wsagent")
         skynet.error(string.format("%s connected, pass it to agent :%08x", addr, agent))
         skynet.send(agent, "lua", id, "start")
     end)
 end)

这里每次侦听到一个新连接后就建立wsagent，后续的握手及数据传输一并交给其处理。

3）在lualib下建立websocket文件夹，放入handshake.lua（握手协议）、frame.lua（帧数据格式解析）、bit.lua、tools.lua。在wsagent.lua中实现握手、数据传输、关闭连接如下：

 local skynet = require "skynet"
 local socket = require "skynet.socket"
 local frame  = require "websocket.frame"
 local handshake = require "websocket.handshake"
 local sockethelper = require "http.sockethelper"

 local agent = { }
 local REQUEST = { }
 local FD, read, write

 local function _send(message)
     local encoded = frame.encode(message, frame.TEXT)
     write(encoded)
 end

 local function _handshake(fd)
     FD = fd
     read  = sockethelper.readfunc(fd)
     write = sockethelper.writefunc(fd)

     local header = ""
     while true do
         local bytes = read()
         header = header .. bytes
         if #header >  then
             skynet.error("<websocket.handshake>error: header size > 8192")
             return
         end

         local _, to = header:find("\r\n\r\n", -#bytes-, true)
         if to then
             header = header:sub(, to)
             break
         end
     end

     print("accept handshake http request:" .. header)

     local protocols = { } -- todo: how to set protocols?
     local response, protocol = handshake.accept_upgrade(header, protocols)
     if not response then
         skynet.error("<websocket.handshake>error: handshake parse header fault")
         return
     end

     print("send handshake http response:" .. response)

     write(response)
     skynet.error(string.format("<websocket.handshake>web socket %q connection established", fd))

     return true
 end

 local function _close()
     local encoded = frame.encode_close(, 'force close')
     encoded = frame.encode(encoded, frame.CLOSE)

     print("force close:" .. encoded)

     write(encoded)
     socket.close(FD)
 end

 local function _dispatch(text, opcode)
     print(string.format("<websocket>opcode:%q message:%q", opcode, text))

     local TEXT  = assert(frame.TEXT)
     local CLOSE = assert(frame.CLOSE)
     assert(opcode == TEXT or opcode == CLOSE, opcode)

     if opcode == TEXT then
         -- todo: logic
         return true
     end

     if opcode == CLOSE then
         local code, reason = frame.decode_close(message)
         print(string.format("<websocket>CLOSE code:%q reason:%q", code, reason))
         local encoded = frame.encode_close(code)
         encoded = frame.encode(encoded, frame.CLOSE)

         local ok, err = pcall(write, encoded)
         if not ok then
             -- remote endpoint may has closed tcp-connection already
             skynet.error("write close protocol failure:" .. tostring(err))
         end
         socket.close(assert(FD))
     end
 end

 local function _recv()
     local last
     local frames = {}
     local first_opcode

     while true do
         -- skynet will report error and close socket if socket error (see socket.lua)
         local encoded = read()
         if last then
             encoded = last .. encoded
             last = nil
         end

         repeat
             local decoded, fin, opcode, rest = frame.decode(encoded)
             if decoded then

                 if not first_opcode then
                     first_opcode = opcode
                 end
                 table.insert(frames, decoded)
                 encoded = rest
                 if fin == true then
                     if not _dispatch(table.concat(frames), first_opcode) then
                         -- socket closed in [_dispatch]
                         return
                     end
                     frames = { }
                     first_opcode = nil
                 end
             end
         until (not decoded)

         if #encoded >  then
             last = encoded
         end
     end
 end

 function agent.start(fd)
     socket.start(fd)

     skynet.error("<websocket>start handshake")
     if not _handshake(fd) then
         socket.close(fd)
         skynet.exit()
         return
     end

     skynet.error("<websocket>receive and dispatch")
     _recv()

     skynet.error("<websocket>exit")
     skynet.exit()
 end

 skynet.start(function()
     skynet.dispatch("lua", function (_, _, fd, method, ...)
         local f = assert(agent[method])
         skynet.retpack(f(fd, ...))
     end)
 end)

代码我已放到git上：https://github.com/zhoujijian/skynet-websocket