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服务识别。