skynet源碼分析之snax

snax是一個方便實現skynet服務的簡單框架，對服務的接口（比如skynet.call, skynet.send等）做了進一步的封裝，編寫snax服務比較容易，詳情參考官方wiki https://github.com/cloudwu/skynet/wiki/Snax

下面是一個簡單的snax服務代碼，並不是獨立的Lua程序。包含了一組Lua函數，會被snax框架加載分析。一般至少包含4組函數：init，服務的初始接口；exit，服務的退出接口；response前綴，響應其他服務請求並給出回應的方法；accept前綴，響應其他服務請求不需要回應的方法。

    -- print("xxx")
 1  function response.f1(msg)
     return a .. msg
 end
 
 function response.f2(msg)
     return a .. msg
 end
 
 function accept.g1(...)
     print(...)
 end
 
 function accept.g2(...)
     print(...)
 end
 
 function init()
     print("test start!!!")
 end
 
 function exit()
     print("test exit!!!")
 end

1. snax框架如何分析Lua代碼

接下來重點分析snax框架如何加載分析Lua代碼：

第10行，返回一個閉包，需三個參數：name，snax服務的名字；G，全局環境，默認是空表{}；loader，加載Lua文件的接口，不提供則用默認的。

第4-18行，默認的加載器，通過Lua文件名匹配到路徑，然后調用loadfile加載Lua文件。注：這時不能用print，math系統api，因為還未設置package.path路徑。

第24-40行，注冊response組和accept組的接口信息，對參數做相關檢查，比如不能出現相同的接口名字

第55-62行，注冊system組的接口信息

第64-65行，注冊response組合accept組接口信息

第78-81行，用指定loader加載器加載Lua代碼

第83-85行，分析（運行）Lua代碼，設置了全局環境G的__index=env,__newindex=init_system。以上面代碼為例，分析流程：

            response.f1 -> env.reponse -> func_id -> count，把接口信息保存在func里（第37行）

            response.f2, accept.g1, accept.g2流程同上

            init -> init_system，把函數原型保存在接口信息第4個索引位置（第72行），前3個位置是{1, "system", "init"}

            exit -> init_system，把函數原型保存在接口信息第4個索引位置（第72行），前3個位置是{1, "system", "exit"}

-- lualib/snax/interface.lua
local skynet = require "skynet"

local function dft_loader(path, name, G)
    local errlist = {}

    for pat in string.gmatch(path,"[^;]+") do
        local filename = string.gsub(pat, "?", name)
        local f , err = loadfile(filename, "bt", G)
        if f then
            return f, pat
        else
            table.insert(errlist, err)
        end
    end

    error(table.concat(errlist, "\n"))
end

return function (name , G, loader)
    loader = loader or dft_loader
    local mainfunc

    local function func_id(id, group)
        local tmp = {}
        local function count( _, name, func)
            if type(name) ~= "string" then
                error (string.format("%s method only support string", group))
            end
            if type(func) ~= "function" then
                error (string.format("%s.%s must be function"), group, name)
            end
            if tmp[name] then
                error (string.format("%s.%s duplicate definition", group, name))
            end
            tmp[name] = true
            table.insert(id, { #id + 1, group, name, func} )
        end
        return setmetatable({}, { __newindex = count })
    end

    do
        assert(getmetatable(G) == nil)
        assert(G.init == nil)
        assert(G.exit == nil)

        assert(G.accept == nil)
        assert(G.response == nil)
    end

    local temp_global = {}
    local env = setmetatable({} , { __index = temp_global })
    local func = {}

    local system = { "init", "exit", "hotfix", "profile"}

    do
        for k, v in ipairs(system) do
            system[v] = k
            func[k] = { k , "system", v }
        end
    end

    env.accept = func_id(func, "accept")
    env.response = func_id(func, "response")
    local function init_system(t, name, f)
        local index = system[name]
        if index then
            if type(f) ~= "function" then
                error (string.format("%s must be a function", name))
            end
            func[index][4] = f
       else
            temp_global[name] = f
       end
   end

   local pattern

   local path = assert(skynet.getenv "snax" , "please set snax in config file")
   mainfunc, pattern = loader(path, name, G)

   setmetatable(G, { __index = env , __newindex = init_system })
   local ok, err = xpcall(mainfunc, debug.traceback)
   setmetatable(G, nil)
   assert(ok,err)

   for k,v in pairs(temp_global) do
       G[k] = v
   end

   return func, pattern
end

第92行，返回分析后的接口信息func。即：

{{1, "system", "init", f}, {2, "system", "exit", f}, {3, "system", "hotfix", f}, {4, "system", "profile", f}, {5, "response", "f1", f}, {6, "response", "f2", f}, {7, "accept", "g1", f}, {8, "accept", "g2", f},}

snax.interface api是將snax_interface返回的一維表轉化成key-value形式。即：

{
name = "test",
system = {init=1, exit=2, hotfix=3, profile=4},
reponse = {f1=5, f2=6},
accept = {g1=7, g2=8},
}

-- lualib/skynet/snax.lua
 function snax.interface(name)
     if typeclass[name] then
         return typeclass[name]
     end
 
     local si = snax_interface(name, G)
 
     local ret = {
         name = name,
         accept = {},
         response = {},
         system = {},
     }
 
     for _,v in ipairs(si) do
         local id, group, name, f = table.unpack(v)
         ret[group][name] = id
     end
 
     typeclass[name] = ret
     return ret
 end

 2. snaxd服務

介紹完snax框架如何分析Lua代碼，接下來介紹snax服務的工作流程：

第2行，通過snax.newservice啟動一個snaxd服務，服務名為name

第8行，分析加載服務名對應的Lua文件

第9行，啟動名稱為"snaxd"的snlua服務，參數是name

第12行，給該服務發送"snax"類型消息，第一個參數是t.system.init（即id是1）

-- lualib/skynet/snax.lua
function snax.newservice(name, ...)
    local handle = snax.rawnewservice(name, ...)
    return snax.bind(handle, name)
end

function snax.rawnewservice(name, ...)
    local t = snax.interface(name)
    local handle = skynet.newservice("snaxd", name)
    assert(handle_cache[handle] == nil)
    if t.system.init then
        skynet.call(handle, "snax", t.system.init, ...)
    end
    return handle
end

啟動snaxd服務過程，

第2-10行，分析snax服務的Lua代碼，設置package.path路徑以及SERVICE_NAME,SERVICE_PATH等

第47行，設置"snax"類型的消息分發函數dispatcher。調用snax.newservice會收到"snax"消息，第一個參數id是1(t.system.init)，在system組里：

         第15行，通過id獲取接口信息，此時method={1, "system", "init", f}，然后執行24行分支

         第24-32行，執行snax服務的Lua文件的init函數，即snax服務的初始化邏輯放到init函數里

         第34-40行，同理，snax服務退出時，通常把退出邏輯放到exit函數里。除了init、exit，system組還包含hotfix,profile，都有相應的處理。

-- service/snaxd.lua
local snax_name = tostring(...)
local loaderpath = skynet.getenv"snax_loader"
local loader = loaderpath and assert(dofile(loaderpath))
local func, pattern = snax_interface(snax_name, _ENV, loader)
local snax_path = pattern:sub(1,pattern:find("?", 1, true)-1) .. snax_name ..  "/"
package.path = snax_path .. "?.lua;" .. package.path

SERVICE_NAME = snax_name
SERVICE_PATH = snax_path

skynet.start(function()
    local init = false
    local function dispatcher( session , source , id, ...)
        local method = func[id]

        if method[2] == "system" then
            local command = method[3]
            if command == "hotfix" then
                local hotfix = require "snax.hotfix"
            　　 skynet.ret(skynet.pack(hotfix(func, ...)))
        　　 elseif command == "profile" then
                skynet.ret(skynet.pack(profile_table))
            elseif command == "init" then
                assert(not init, "Already init")
                local initfunc = method[4] or function() end
                initfunc(...)
                skynet.ret()
                skynet.info_func(function()
                    return profile_table
                end)
                init = true
            else
                assert(init, "Never init")
                assert(command == "exit")
                local exitfunc = method[4] or function() end
                exitfunc(...)
                skynet.ret()
                init = false
                skynet.exit()
            end
        else
            assert(init, "Init first")
            timing(method, ...)
        end
    end
    skynet.dispatch("snax", dispatcher)

    -- set lua dispatcher
    function snax.enablecluster()
        skynet.dispatch("lua", dispatcher)
    end
end)

3. 給snaxd服務發送消息

snax.newservice啟動服務后，通過snax.bind綁定后返回一個對象，對象里包含接口信息，供使用者調用：

第8-12行，如果已經綁定過，從緩存里獲取即可

第13-14行，獲取Lua代碼接口信息，然后通過wrapper封裝

第19-26行，返回一個table，包含4個域：handle，服務地址；type，服務名稱；post，不需要返回的請求；req，需要返回的請求。

當我們用經典的test.req.f1()給test服務發送消息，流程是：調用req域 -> gen_req接口(第28行) -> 獲取接口編號id(第31行) -> 給handle服務(snaxd)發送消息(第36行)

-- lualib/skynet/snax.lua
function snax.newservice(name, ...)
    local handle = snax.rawnewservice(name, ...)
    return snax.bind(handle, name)
end

function snax.bind(handle, type)
    local ret = handle_cache[handle]
    if ret then
        assert(ret.type == type)
        return ret
    end
    local t = snax.interface(type)
    ret = wrapper(handle, type, t)
    handle_cache[handle] = ret
    return ret
end

local function wrapper(handle, name, type)
    return setmetatable ({
        post = gen_post(type, handle),
        req = gen_req(type, handle),
        type = name,
        handle = handle,
    }, meta)
end

local function gen_req(type, handle)
    return setmetatable({} , {
        __index = function( t, k )
            local id = type.response[k]
            if not id then
                error(string.format("request %s:%s no exist", type.name, k))
            end
            return function(...)
                return skynet_call(handle, "snax", id, ...)
            end
    end })
end

snaxd服務收到消息后，因為是response/accept組的信息，最終調用timing(method, ...)。如果是accept類型，直接執行對應的函數即可（第4行）；如果是response類型，執行對應的函數並返回（第17行）。至此，完成跟snax服務一次交互。

 -- service/snaxd.lua
 local function timing( method, ... )
     local err, msg
     profile.start()
     if method[2] == "accept" then
         -- no return
         err,msg = xpcall(method[4], traceback, ...)
     else
         err,msg = xpcall(return_f, traceback, method[4], ...)
     end
     local ti = profile.stop()
     update_stat(method[3], ti)
     assert(err,msg)
 end

 local function return_f(f, ...)
     return skynet.ret(skynet.pack(f(...)))
 end

 4. snax服務的熱更新

snax服務支持熱更新（只能熱更snax類型的服務）。snax框架約定了Lua文件的格式，所以可獲取Lua代碼里所有閉包信息，通過修改這些閉包狀態達到熱更的目的。調用snax.hotfix進行熱更新（可在debug_console加一個hotfix命令調用snax.hotfix接口），最終調用到inject接口（第9行）。

-- lualib/skynet/snax.lua
function snax.hotfix(obj, source, ...)
    local t = snax.interface(obj.type)
    return test_result(skynet_call(obj.handle, "snax", t.system.hotfix, source, ...))
end

-- lualib/snax/hotfix.lua
return function (funcs, source, ...)
    return pcall(inject, funcs, source, ...)
end

inject接口的參數：funcs原Lua文件的接口信息，source要熱更的Lua代碼塊，以及可變參數。工作流程是：

第2行，通過snax_interface接口分析加載要熱更的Lua代碼，保存在patch變量中。

第3行，通過funcs獲取原有Lua代碼所有閉包。

第5-10行，依次處理patch里的每個閉包，調用_patch：

           第25-41行，獲取閉包每個上值的名字和值，如果熱更的Lua代碼里沒提供值，則表示這個上值不需要熱更，復用原來的值即可，即調用debug.upvaluejoin將現有閉包引用原有的上值

           第21行，更新完一個閉包的所有上值后，覆蓋原來的接口信息。

第12-15行，運行熱更的Lua代碼里的hotfix接口，在這個接口里可以查看和修改服務的狀態（內部local變量的值）。示例參看官方wiki。

local function inject(funcs, source, ...)
    local patch = si("patch", dummy_env, loader(source))
    local global = collect_all_uv(funcs)

    for _, v in pairs(patch) do
        local _, group, name, f = table.unpack(v)
        if f then
            patch_func(funcs, global, group, name, f)
        end
    end

    local hf = find_func(patch, "system", "hotfix")
    if hf and hf[4] then
        return hf[4](...)
    end
end

local function patch_func(funcs, global, group, name, f)
    local desc = assert(find_func(funcs, group, name) , string.format("Patch mismatch %s.%s", group, name))
    _patch(global, f)
    desc[4] = f
end

local function _patch(global, f)
    local i = 1
    while true do
        local name, value = debug.getupvalue(f, i)
        if name == nil then
            break
        elseif value == nil or value == dummy_env then
            local old_uv = global[name]
            if old_uv then
                debug.upvaluejoin(f, i, old_uv.func, old_uv.index)
            end
        else
           if type(value) == "function" then
               _patch(global, value)
           end
        end
        i = i + 1
    end
end

 總結：snax是一個簡單實用的框架，對比用原生的skynet接口，snax編寫出的Lua代碼更加直觀易懂，且熱更新也比較方便。但有幾個易錯點：

  1. snax.queryservice會發送rpc請求，是個阻塞調用。

  2. 編寫的Lua服務在loadfile過程中不能調用print，math等系統接口，因為還未設置package.path路徑。當然，也可以自己設置加載器支持指定的系統接口。

  3.  snax熱更不能增加新的遠程response/accept方法。已經新增加的方法不能被snaxd服務識別。