skynet源码分析之snlua服务的启动流程(二)

通过前一篇文章(http://www.cnblogs.com/RainRill/p/8485024.html)了解了skynet启动snlua服务的整体流程，这篇文章补充上一篇未介绍的内容。

1. 消息类型

skynet定义了多个不同的消息类型，每种类型的处理方式不一样，在服务启动流程中需注册用到的消息类型的消息处理协议。否则，收到对应类型的消息时会因没有消息处理协议而报错。

-- lualib/skynet.lua
local skynet = {
    -- read skynet.h
    PTYPE_TEXT = 0,
    PTYPE_RESPONSE = 1,
    PTYPE_MULTICAST = 2,
    PTYPE_CLIENT = 3,
    PTYPE_SYSTEM = 4,
    PTYPE_HARBOR = 5,
    PTYPE_SOCKET = 6,
    PTYPE_ERROR = 7,
    PTYPE_QUEUE = 8,        -- used in deprecated mqueue, use skynet.queue instead
    PTYPE_DEBUG = 9,
    PTYPE_LUA = 10,
    PTYPE_SNAX = 11,
}

一个消息处理协议一般包含：

name 字符串，协议类型名称，比如Lua类型，其值为"Lua"

id 对应的消息类型，如上

pack 发送消息时，对消息包进行打包的函数

unpack 收到消息时，对消息包进行解包的函数，再传给dispatch函数 ，实现消息回调

dispatch 消息回调函数，通常由用户自己指定

在require "skynet"中，指定了Lua服务三种必须指定的消息处理协议：“lua”通用的Lua服务消息处理类型，dispatch由用户自己指定；"response"请求的回应消息，不用指定dispatch，是因为收到回应消息时，重启对应的co即可；“error”发生异常时的消息，调用_error_dispatch

// lualib/skynet.lua
do
    local REG = skynet.register_protocol

    REG {
        name = "lua",
        id = skynet.PTYPE_LUA,
        pack = skynet.pack,
        unpack = skynet.unpack,
    }

    REG {
        name = "response",
        id = skynet.PTYPE_RESPONSE,
    }

    REG {
        name = "error",
        id = skynet.PTYPE_ERROR,
        unpack = function(...) return ... end,
        dispatch = _error_dispatch,
    }
end

通常在服务的入口脚本里指定"lua"协议的dispatch函数(skynet.dispatch)，以及需要的其他额外协议类型(skynet.register_protocol)，例如：

-- service/launcher.lua
skynet.register_protocol {
    name = "text",
    id = skynet.PTYPE_TEXT,
    unpack = skynet.tostring,
    dispatch = function(session, address , cmd)
        if cmd == "" then
            command.LAUNCHOK(address)
        elseif cmd == "ERROR" then
            command.ERROR(address)
        else
            error ("Invalid text command " .. cmd)
        end
    end,
}

skynet.dispatch("lua", function(session, address, cmd , ...)
    cmd = string.upper(cmd)
    local f = command[cmd]
    if f then
        local ret = f(address, ...)
        if ret ~= NORET then
            skynet.ret(skynet.pack(ret))
        end
    else
        skynet.ret(skynet.pack {"Unknown command"} )
    end
end)

2. 在Lua服务里创建另一个Lua服务

通常需要在一个Lua服务创建另一个Lua服务，比如在A服务里创建B服务，一般是用skynet.newservice，即给".launcher"服务发送一个"lua"类型的消息

 -- lualib/skynet.lua
 function skynet.newservice(name, ...)    
     return skynet.call(".launcher", "lua" , "LAUNCH", "snlua", name, ...)
 end

“.launcher”服务收到消息后，调用command.LAUNCH，然后调用skynet.launch(第4行)，然后调用C层的command(第23行)，

-- service/launcher.lua
local function launch_service(service, ...)
    local param = table.concat({...}, " ")
    local inst = skynet.launch(service, param)
    local response = skynet.response()
    if inst then
        services[inst] = service .. " " .. param
        instance[inst] = response
    else
        response(false)
        return
    end
    return inst
end

function command.LAUNCH(_, service, ...)
    launch_service(service, ...)
    return NORET
end

-- lualib/skynet/manager.lua
function skynet.launch(...)
    local addr = c.command("LAUNCH", table.concat({...}," "))
    if addr then
        return tonumber("0x" .. string.sub(addr , 2))
    end
end

最后调用cmd_launch，创建一个ctx(第10行)。

// skynet-src/skynet_server.c
static const char *
cmd_launch(struct skynet_context * context, const char * param) {//启动一个新ctx
        size_t sz = strlen(param);
        char tmp[sz+1];
        strcpy(tmp,param);
        char * args = tmp;
        char * mod = strsep(&args, " \t\r\n");
        args = strsep(&args, "\r\n");
        struct skynet_context * inst = skynet_context_new(mod,args);
        if (inst == NULL) {
                return NULL;
        } else {
                id_to_hex(context->result, inst->handle);
                return context->result;
        }
}

之后回到launcher.lua，调用skynet.response暂停当前co，调用suspend(类型是"RESPONSE)，resume重启co(第24行)，返回一个Lua函数response

local response = skynet.response()

 // lualib/skynet.lua
 function skynet.response(pack)
         pack = pack or skynet.pack
         return coroutine_yield("RESPONSE", pack)
 end

function suspend(co, result, command, param, size)
     ...
     elseif command == "RESPONSE" then
         local co_session = session_coroutine_id[co]
         local co_address = session_coroutine_address[co]
         if session_response[co] then
             error(debug.traceback(co))
         end
         local f = param
         local function response(ok, ...)
             ...
         end
         watching_service[co_address] = watching_service[co_address] + 1
         session_response[co] = true
         unresponse[response] = true
         return suspend(co, coroutine_resume(co, response))
end

在launcher.lua里，以ctx的handle id为key，Lua函数response为value保存在instance里，

instance[inst] = response

新创建的B服务的入口脚本最后会调用skynet.start，在下一帧会调用skynet.init_service，在成功执行完start_func后(第3行，如何执行参考http://www.cnblogs.com/RainRill/p/8466368.html)，最后会向".launcher"服务发送一条消息(第9行)

-- lualib/skynet.lua
function skynet.init_service(start)
    local ok, err = skynet.pcall(start)
    if not ok then
        skynet.error("init service failed: " .. tostring(err))
        skynet.send(".launcher","lua", "ERROR")
        skynet.exit()
    else
        skynet.send(".launcher","lua", "LAUNCHOK")
    end
end

function skynet.start(start_func)
    c.callback(skynet.dispatch_message) -- 上一篇介绍了
    skynet.timeout(0, function()
        skynet.init_service(start_func)
    end)
end

".launcher"服务收到消息后，调用command.LAUNCHOK，找到之前保存的response函数，然后执行它

-- service/launcher.lua
function command.LAUNCHOK(address)
    -- init notice
    local response = instance[address]
    if response then
        response(true, address)
        instance[address] = nil
    end

    return NORET
end

在response函数里，向co_address（此时是A服务）发送一条"RESPONSE"类型消息，消息包是打包B服务地址后的数据（f(...)），即告诉A服务新创建的B服务的地址。

-- lualib/skynet.lua
local function response(ok, ...)
    ...
    ret = c.send(co_address, skynet.PTYPE_RESPONSE, co_session, f(...)) ~= nil
    return ret
end

这就是snlua服务启动的整个流程。接下来会介绍skynet里的Lua层消息处理机制，从而理解skynet如何实现高并发。