skynet源码分析之socketchannel

请求回应模式是与外部交互最常用的模式之一。通常协议设计方式有两种：1.每个请求包对应一个回应包，有tcp保证时序，先请求的先回应，但不必收到回应才发送下一个请求，redis的协议就是这种类型；2.每个请求带一个唯一的session标识，回应包也带这个标识。这样每个请求不一定都需要回应，且不用遵循先请求先回应的时序。mongodb的协议就是这种类型。skynet提供socketchannel库封装内部细节，支持上面两种模式。详情参考官方wiki https://github.com/cloudwu/skynet/wiki/SocketChannel

调用socketchannel.channel创建一个channel对象，必须提供ip地址(可以是域名)和端口。采用第一种还是第二种模式依据是否提供response参数，redis没有提供说明用的第一种模式，mongo提供了（第13行）说明用第二种模式。

-- lualib/skynet/db/redis.lua
 local channel = socketchannel.channel {
     host = db_conf.host,
     port = db_conf.port or 6379,
     auth = redis_login(db_conf.auth, db_conf.db),
     nodelay = true,
 }
 
 -- lualib/skynet/db/mongo.lua
 obj.__sock = socketchannel.channel {
     host = obj.host,
     port = obj.port,
     response = dispatch_reply,
     auth = mongo_auth(obj),
     backup = backup,
     nodelay = true,
 }
 
 -- lualib/skynet/socketchannel.lua
 function socket_channel.channel(desc)
     local c = {
         __host = assert(desc.host),
         __port = assert(desc.port),
         __backup = desc.backup,
         __auth = desc.auth,
         __response = desc.response,     -- It's for session mode
         __request = {}, -- request seq { response func or session }     -- It's for order mode
         __thread = {}, -- coroutine seq or session->coroutine map
         __result = {}, -- response result { coroutine -> result }
         __result_data = {},
         __connecting = {},
         __sock = false,
         __closed = false,
         __authcoroutine = false,
         __nodelay = desc.nodelay,
     }
 
     return setmetatable(c, channel_meta)
 end

创建完对象后，可以手动调用connect连接对端，如果不connect，在第一次发送请求的时候会尝试去连接。最终调用到connect_once，

第7行，调用socket库api连接对端

第11行，fork一个协程专门处理收到回应包

15-21行，如果是模式1，收到回应包后的处理函数是dispatch_by_order，模式2则是dispatch_by_session

-- lualib/skynet/socketchannel.lua
local function connect_once(self)
    if self.__closed then
        return false
    end
    assert(not self.__sock and not self.__authcoroutine)
    local fd,err = socket.open(self.__host, self.__port)
    ...

    self.__sock = setmetatable( {fd} , channel_socket_meta )
    self.__dispatch_thread = skynet.fork(dispatch_function(self), self)
    ...
end

local function dispatch_function(self)
    if self.__response then
        return dispatch_by_session
    else
        return dispatch_by_order
    end
end

接下来先介绍发送请求包的流程，之后再介绍如何处理回应包。调用者通过channel:request发送请求包，该接口有三个参数：参数request请求包数据；参数response在模式1下是一个function用来接收回应包，模式2下是一个唯一的session值；参数padding可选，表示将巨大消息拆分成多个小包发送出去。

第2行，检测是否已连接，如果未连接，会尝试去连接

第8行，调用socket库把发送请求包。

第13-16行，不需要回应直接返回。

第18，23，35-48行，保存当前co。如果是模式2，保留session-co映射关系在self.__thread里（38行）；如果是模式1，保留response函数在self.__request里，co在self.__threaad里（41,42行）。

43-46行，如果有暂停的co在等待回应包，重启它。

第24行，暂停当前co，等待对方回应包。当收到回应包时，回应处理函数会重启它。

25-32行，返回结果给调用者。

function channel:request(request, response, padding)
    assert(block_connect(self, true))       -- connect once
    local fd = self.__sock[1]

    if padding then
        ...
    else
        if not socket_write(fd , request) then
            sock_err(self)
        end
    end

    if response == nil then
        -- no response
        return
    end

    return wait_for_response(self, response)
end

local function wait_for_response(self, response)
    local co = coroutine.running()
    push_response(self, response, co)
    skynet.wait(co)

    local result = self.__result[co]
    self.__result[co] = nil
    local result_data = self.__result_data[co]
    self.__result_data[co] = nil
    ...

    return result_data
end

local function push_response(self, response, co)
    if self.__response then
        -- response is session
        self.__thread[response] = co
    else
        -- response is a function, push it to __request
        table.insert(self.__request, response)
        table.insert(self.__thread, co)
        if self.__wait_response then
            skynet.wakeup(self.__wait_response)
            self.__wait_response = nil
        end
    end
end

对于模式1的回应处理函数dispatch_by_order，

第4行，调用pop_response获取第一个未回应的请求包的response和co

第6行，调用response函数，response函数调用socket库的readline/read（24行）来等待socket上的返回，是一个阻塞操作。等socket返回后，response函数返回

第11-16行，返回结果保存在self.__result_data

第17行，重启调用者发送请求包的co，把结果返回给调用者（上面代码的26-32行），至此完成一次与对端请求回应交互

-- lualib/skynet/socketchannel.lua
local function dispatch_by_order(self)
    while self.__sock do
        local func, co = pop_response(self)
        ...
        local ok, result_ok, result_data, padding = pcall(func, self.__sock)
        if ok then
            if padding and result_ok then
                ...
            else
                self.__result[co] = result_ok
                if result_ok and self.__result_data[co] then
                    table.insert(self.__result_data[co], result_data)
                else
                    self.__result_data[co] = result_data
                end
                skynet.wakeup(co)
            end
        end
end

-- lualib/skynet/db/redis.lua
local function read_response(fd)
    local result = fd:readline "\r\n"
    local firstchar = string.byte(result)
    local data = string.sub(result,2)
    return redcmd[firstchar](fd,data)
end

对于模式2的回应处理函数dispatch_by_session，

第6行，调用response函数，response函数会调用socket库的readline/read（30行）来等待socket上的返回，是一个阻塞操作。等socket返回后，response函数返回回应包（回应包包含唯一的session）

第8行，通过session获取对应的co

第13-21行，接下来处理跟上面一样，保存回应包内容，重启co。

 -- lualib/skynet/socketchannel.lua
 local function dispatch_by_session(self)
     local response = self.__response
     -- response() return session
     while self.__sock do
         local ok , session, result_ok, result_data, padding = pcall(response, self.__sock)
         if ok and session then
             local co = self.__thread[session]
             if co then
                 if padding and result_ok then
                     ...
                 else
                     self.__thread[session] = nil
                     self.__result[co] = result_ok
                     if result_ok and self.__result_data[co] then
                         table.insert(self.__result_data[co], result_data)
                     else
                         self.__result_data[co] = result_data
                     end
                     skynet.wakeup(co)
                 end
             else
                 self.__thread[session] = nil
                 skynet.error("socket: unknown session :", session)
             end
 end
 
 -- lualib/skynet/db/mongo.lua
 local function dispatch_reply(so)
     local len_reply = so:read(4)
     local reply     = so:read(driver.length(len_reply))
     ...
     return reply_id, succ, result
 end