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", 8001)
    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 > 8192 then
            skynet.error("<websocket.handshake>error: header size > 8192")
            return
        end

        local _, to = header:find("

", -#bytes-3, true)
        if to then
            header = header:sub(1, 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(1000, '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 > 0 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