skynet热更新之inject

游戏服务器的热更新是一种常见的需求，skynet可以通过inject的方式，来修改一个服务的消息处理函数，达到热更新的效果。

skynet内置服务debug_console

skynet自带了一个调试控制台服务。inject注入代码需要先启动这个服务。

skynet.newservice("debug_console", "127.0.0.1", "9666")

启动之后，我们可以用telnet或者nc等指令来登录调试控制台。

> nc 127.0.0.1 9666

输入list指令，可以得到当前系统中所有服务的地址：

list
:00000004       snlua cdummy
:00000006       snlua datacenterd
:00000007       snlua service_mgr
:00000008       snlua main
:00000009       snlua debug_console 127.0.0.1 9666
:0000000a       snlua serviceA
<CMD OK>

输入inject指令，我们可以将某个代码文件，注入到指定的服务中：

inject :0000000a service/hotfix.lua

<CMD OK>

更多的debug_console指令可以参考这里

inject实例

我们在系统启动时，打开debug_console，然后启动服务serviceA，接着设置每隔5秒给serviceA发送两个lua消息，一个参数bar，一个参数foo，代码如下：

--main.lua
local skynet = require "skynet"
skynet.start(function()
    skynet.newservice("debug_console", "127.0.0.1", "9666")
    local addr = skynet.newservice("serviceA")
    
    local function tick()
        skynet.send(addr, "lua", "foo")
        skynet.send(addr, "lua", "bar")
        skynet.timeout(500, tick)
    end

    skynet.timeout(500, tick)
end)

在服务serverA中，我们根据参数，调用不同的处理函数：

--serviceA.lua
local skynet = require "skynet"
local handles = {}

handles.foo = function()
    print("foo")
end

skynet.start(function()
    skynet.dispatch("lua", function(session, source, cmd, ...)
        local handle = handles[cmd]
        if handle then
            handle()
        else
            print("cmd not found", cmd)
        end
    end)
end)

现在我们启动skynet，可以看到每隔5秒输出：

foo
cmd not found   bar

现在我们新建一个文件hotfix.lua：

--hotfix.lua
local handles = _P.lua.handles
local print = _G.print
handles.foo = function()
    print("foo after hotfix")
end

handles.bar = function()
    print("bar after hotfix")
end

接下来连接到控制台，并输入inject指令：

echo 'inject :0000000a services/hotfix.lua' | nc 127.0.0.1 9666

等到下次输出的时候，我们看到的就是：

foo after hotfix
bar after hotfix

更新完成，修改了foo函数，新增了bar函数。

使用inject调用hotfix.lua时，print函数是被修改过成debug_console的返回输出函数，所以如果要用到print的话，需要使用全局变量_G.print

对upValue的处理

如果我们的serviceA是这样的：

--serviceA.lua
local skynet = require "skynet"
local handles = {}

local N = 1
local T = {
    count = 0,
}

handles.foo = function()
    N = N + 2
    T.count = T.count + 1
    print("foo", N, T.count)
end

handles.bar = function()
    N = N - 1
    print("bar", N)
end

skynet.start(function()
    skynet.dispatch("lua", function(session, source, cmd, ...)
        local handle = handles[cmd]
        if handle then
            handle()
        else
            print("cmd not found", cmd)
        end
    end)
end)

foo函数带有两个upValue: N和T，bar函数带有一个upValue: N 如果hotfix.lua文件没有做特殊处理，直接覆盖函数的话，那么就会丢失这些upValue。那么，要怎么处理这些upValue呢？这里需要用到lua的debug库，主要是两个函数：

• debug.getupvalue(f, i): 获取函数f中的第i个upValue的变量名和值。
• debug.upvaluejoin(f1, i, f2, j)：让函数f1的第i个upValue引用f2中的第j个upValue。

热更新带有upValue的函数，我们的hotfix.lua分三步走：

1. 定义一个函数get_up，来获取原有的函数的upValue列表。
2. 定义新的处理函数。
3. 定义一个函数uv_join，将新函数的upValue和旧函数的upValue绑定起来。

完整代码如下：

local handles = _P.lua.handles
local print = _G.print

local function get_up(f)
    local u = {}
    if not f then
        return u
    end
    local i = 1
    while true do
        local name = debug.getupvalue(f, i)
        if name == nil then
            return u
        end
        u[name] = i
        i = i + 1
    end
    return u
end

local function uv_join(f, old_f, old_uv)
    local i = 1
    while true do
        local name = debug.getupvalue(f, i)
        if not name then
            break
        end

        if old_uv[name] then
            debug.upvaluejoin(f, i, old_f, old_uv[name])
        end
        i = i + 1
    end
end

local foo = handles.foo
local up = get_up(foo)

local N, T      --定义两个upValue，否则函数里会变成全局变量
handles.foo = function()
    N = N + 200
    T.count = T.count + 100
    print("foo", N, T.count)
end
uv_join(handles.foo, foo, up)

这里的get_up函数只取了传入函数的upValue，如果要嵌套处理函数中的函数，可以参考lualib/skynet/inject.lua中的getupvaluetable函数。

inject实现原理

debug_console服务的代码位于service/debug_console.lua文件中，其对inject指令的处理，其实就是发送一条debug类型的消息到目标服务：

--debug_console.lua
function COMMAND.inject(address, filename, ...)
	address = adjust_address(address)
	local f = io.open(filename, "rb")
	if not f then
		return "Can't open " .. filename
	end
	local source = f:read "*a"
	f:close()
	local ok, output = skynet.call(address, "debug", "RUN", source, filename, ...)
	if ok == false then
		error(output)
	end
	return output
end

在我们的服务中，当我们require 'skynet'的时候，会自动注册debug消息类型的处理：

--lualib/skynet.lua
-- Inject internal debug framework
local debug = require "skynet.debug"
debug.init(skynet, {
	dispatch = skynet.dispatch_message,
	suspend = suspend,
	resume = coroutine_resume,
})

--lualib/skynet/debug.lua
    skynet.register_protocol {
		name = "debug",
		id = assert(skynet.PTYPE_DEBUG),
		pack = assert(skynet.pack),
		unpack = assert(skynet.unpack),
		dispatch = _debug_dispatch,
	}

其中，参数RUN是这样处理的

--lualib/skynet/debug.lua
function dbgcmd.RUN(source, filename, ...)
    local inject = require "skynet.inject"
    local args = table.pack(...)
    local ok, output = inject(skynet, source, filename, args, export.dispatch, skynet.register_protocol)
    collectgarbage "collect"
    skynet.ret(skynet.pack(ok, table.concat(output, "\n")))
end

追溯代码，来到最终的inject函数：

1. 修改print函数，可以返回输出内容给debug_console服务。
2. 在上一层调用的时候，传进来的...实际上两个函数skynet.dispatch_message和skynet.register_protocol，这里将这两个函数，以及函数中包含的子函数，所用到的upVluae都收集起来，存入表u中。
3. proto是skynet.register_protocol中用到的一个upValue，存放着当前服务所注册的消息类型。遍历proto，将每个消息的处理函数用到的upValue收集起来，存放到表p中。
4. 设置环境，调用传入的热更新文件。现在我们知道，在上面的例子中的hotfix.lua，用到的_P，就是存放各种消息类型的处理函数的upValue表。

在控制台调用inject指令时，还可以传入额外的参数，例如：inject :0000000a services/hotfix.lua xxx yyy，最终这两个参数，就是这里的inject函数中的第四个参数args，可以在hotfix.lua中直接使用这两个参数。