skynet源碼分析之熱更新

skynet有兩種方法支持熱更新lua代碼：clearcache和inject，在介紹skynet熱更新機制之前，先介紹skynet控制台，參考官方wiki https://github.com/cloudwu/skynet/wiki/DebugConsole

1. skynet控制台

想要使用skynet控制台，需啟動debug_console服務skynet.newservice("debug_console", ip, port)，指定一個地址。skynet啟動后，用nc命令就可以進入控制台，如圖。

debug_console服務啟動后，監聽外部連接（第3行）。

第15行，當打開控制台連接建立后，fork一個協程在console_main_loop里處理這個tcp連接的通信交互

第6-13行，使用特定的print，數據不是輸出到屏幕上，而是通過socket.write發送給控制台

第24-28行，獲取控制台發來的數據，然后調用docmd

第35-52行，解析出相應指令，執行完后，通過print發送給控制台

-- service/debug_console.lua
skynet.start(function()
    local listen_socket = socket.listen (ip, port)
    skynet.error("Start debug console at " .. ip .. ":" .. port)
    socket.start(listen_socket , function(id, addr)
        local function print(...)
            local t = { ... }
            for k,v in ipairs(t) do
                t[k] = tostring(v)
            end
            socket.write(id, table.concat(t,"\t"))
            socket.write(id, "\n")
        end
        socket.start(id)
        skynet.fork(console_main_loop, id , print)
    end)
end)

local function console_main_loop(stdin, print)
    print("Welcome to skynet console")
    skynet.error(stdin, "connected")
    local ok, err = pcall(function()
        while true do
            local cmdline = socket.readline(stdin, "\n")
            ...
            if cmdline ~= "" then
                docmd(cmdline, print, stdin)
            end
        end
    end)
    ...
end

local function docmd(cmdline, print, fd)
    local split = split_cmdline(cmdline)
    local command = split[1]
    local cmd = COMMAND[command]
    local ok, list
    if cmd then
        ok, list = pcall(cmd, table.unpack(split,2))
    else
        ...
    end

    if ok then
        ...
        print(list)
        print("<CMD OK>")
    else
        print(list)
        print("<CMD Error>")
    end
end

比如，在控制台輸入"list"，最終會調用到COMMAND.list()，獲取當前服務信息，然后返回給控制台。於是就有了上面截圖的信息。

-- service/debug_console.lua
function COMMAND.list()
    return skynet.call(".launcher", "lua", "LIST")
end

2. clearcache更新方法

clearcache用於新建服務的熱更新，比如agent，對已有的服務不能熱更新。使用方法很簡單：在控制台輸入"clearcache"即可，下面分析其原理：

每個snlua服務會啟動一個單獨的lua VM，對於同一份Lua文件，N個服務就要加載N次到內存。skynet對此做了優化，每個Lua文件只加載一次到內存，保存Lua文件-內存映射表，下一個服務加載的時候copy一份內存即可，提高了VM的啟動速度（省掉讀取Lua文件和解析Lua語法的過程）。參考官方wiki https://github.com/cloudwu/skynet/wiki/CodeCache

第2-6行，全局的Lua狀態機，以Lua文件名為key，內存指針為value，保存在狀態機的注冊表里，位於棧上有效偽索引LUA_REGISTERYINDEX處。

第8行，修改了官方的luaL_loadfilex接口：

第11-15行，調用load從全局狀態機的注冊表里獲取文件名對應的內存塊，調用lua_clonefunction拷貝一份后即可返回

第16-18行，第一次加載文件到內存里

第19-26行，調用save保存文件名-內存塊的映射，如果有舊的內存塊，返回舊的，否則返回剛加載的內存塊

  // 3rd/lua/lauxlib.c
  struct codecache {
          struct spinlock lock;
          lua_State *L;
  };
  static struct codecache CC;
  
  LUALIB_API int luaL_loadfilex (lua_State *L, const char *filename,
                                               const char *mode) {
    ...
    const void * proto = load(filename);
    if (proto) {
      lua_clonefunction(L, proto);
      return LUA_OK;
    }
    lua_State * eL = luaL_newstate();
    int err = luaL_loadfilex_(eL, filename, mode);
    proto = lua_topointer(eL, -1);
    const void * oldv = save(filename, proto);
    if (oldv) {
      lua_close(eL);
      lua_clonefunction(L, oldv);
    } else {
      lua_clonefunction(L, proto);
      /* Never close it. notice: memory leak */
    }
  
    return LUA_OK;
  }

load接口，從全局狀態機CC的注冊表里獲取指定文件對應的內存塊（可能不存在）

// 3rd/lua/lauxlib.c
static const void *
 load(const char *key) {
   if (CC.L == NULL)
     return NULL;
   SPIN_LOCK(&CC)
     lua_State *L = CC.L;
     lua_pushstring(L, key);
     lua_rawget(L, LUA_REGISTRYINDEX);
     const void * result = lua_touserdata(L, -1);
     lua_pop(L, 1);
   SPIN_UNLOCK(&CC)
 
   return result;
 }

save接口，先獲取舊的內存塊（12-15行），如果有則直接返回，否則把新內存塊加載到注冊表中（17-19行）

  static const void *
  save(const char *key, const void * proto) {
    lua_State *L;
    const void * result = NULL;
  
    SPIN_LOCK(&CC)
      if (CC.L == NULL) {
        init();
        L = CC.L;
      } else {
        L = CC.L;
        lua_pushstring(L, key);
        lua_pushvalue(L, -1);
        lua_rawget(L, LUA_REGISTRYINDEX);
        result = lua_touserdata(L, -1); /* stack: key oldvalue */
        if (result == NULL) {
          lua_pop(L,1);
          lua_pushlightuserdata(L, (void *)proto);
          lua_rawset(L, LUA_REGISTRYINDEX);
        } else {
          lua_pop(L,2);
        }
      }
    SPIN_UNLOCK(&CC)
    return result;
  }

clearcache的原理就是刪除這個全局的狀態機，這樣新服務就可以用最新的Lua文件（load接口返回NULL），且不影響已有服務的運行。此時，新服務運行新的代碼，舊服務運行舊的代碼。

在控制台輸入"clearcache"后，最終調用到c中的clearcache，刪除舊的全局VM，然后新建一個（19-20行）。

-- service/debug_console.lua
function COMMAND.clearcache()
    codecache.clear()
end

// 3rd/lua/lauxlib.c
static int
cache_clear(lua_State *L) {
    (void)(L);
    clearcache();
    return 0;
}

static void
clearcache() {
    if (CC.L == NULL)
        return;
    SPIN_LOCK(&CC)
    lua_close(CC.L);
    CC.L = luaL_newstate();
    SPIN_UNLOCK(&CC)
}

3. inject更新方法

inject譯為“注入”，即將新代碼注入到已有的服務里，讓服務執行新的代碼，可以熱更已開啟的服務，使用方法簡單，在控制台輸入"inject address xxx.lua"即可，難點在於lua代碼的編寫，建議只做一些簡單的熱更。其實現原理是：給服務發送消息，讓其執行新代碼，新代碼修改已有的函數原型（包括upvalues），完成對函數的更新。

第10行，給指定服務發送"DEBUG"類型消息

第20行，最終調用inject接口注入代碼修改函數原型（包括閉包）。注：只需修改服務的register_protocol接口以及消息分發接口

-- service/debug.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

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

inject的處理過程：

第7-9行，獲取接口的函數原型（包括閉包），保存在u里

第11-21行，遍歷所有的消息分發函數（每種消息類型對應一個函數），通過getupvaluetable接口保存函數原型（包括閉包）

第22-23行，執行新的Lua代碼，通過env里的_U,_P獲取原有的函數原型

-- lualib/skynet/inject.lua
 return function(skynet, source, filename , ...)
     local output = {}
     local u = {}
     local unique = {}
     local funcs = { ... }
     for k, func in ipairs(funcs) do
         getupvaluetable(u, func, unique)
     end
     local p = {}
     local proto = u.proto
     if proto then
         for k,v in pairs(proto) do
             local name, dispatch = v.name, v.dispatch
             if name and dispatch and not p[name] then
                 local pp = {}
                 p[name] = pp
                 getupvaluetable(pp, dispatch, unique)
             end
         end
     end
     local env = setmetatable( { print = print , _U = u, _P = p}, { __index = _ENV })
     local func, err = load(source, filename, "bt", env)
     ...
 
     return true, output
 end

示例：比如啟動了一個test服務

 -- test.lua
 1 local skynet = require "skynet"

local CMD = {}

local function test(...)
    print(...)
    skynet.ret(skynet.pack("OK"))
end

function CMD.ping(msg)
    test(msg)
end

skynet.dispatch("lua", function(session, source, cmd, ...)
    local f = CMD[cmd]
    if f then
        f(...)
    end
end)

skynet.start(function()
end)

在控制台輸入"inject address inject_test.lua"熱更test服務，

第23行，通過全局環境變量_P獲取lua類型消息分發函數里的接口CMD

第24行，獲取CMD.ping接口的所有閉包

第25行，得到test的函數原型

第27-30行，更新接口，完成熱更。

-- inject_test.lua
print("hotfix begin")

if not _P then
    print("hotfix faild, _P not define")
    return
end

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

local CMD = _P.lua.CMD
local upvalues = get_upvalues(CMD.ping)
local test = upvalues.test

CMD.ping = function(msg)
    local postfix = "aaa"
    test(msg .. postfix)
end

print("hotfix end")