skynet范例研究-服务端

源码分为3个文件夹，分别为service、lualib、src。

其中service主要是服务端 业务逻辑 ，lualib为 基础工具封装 ，src为 C语言服务封装 。

一般阅读代码时先从main入手，跟着逻辑一步一步不断深入。

main.lua

文件路径：service/main.lua

local skynet = require "skynet"skynet.start(function()    skynet.error("Server start")    -- 打印Server start    if not skynet.getenv "daemon" then        local console = skynet.newservice("console")    -- 创建控制台    end    skynet.newservice("debug_console",8000)            -- 启动控制台服务    local proto = skynet.uniqueservice "protoloader"    -- 启动封装的protoloader服务    skynet.call(proto, "lua", "load", {                -- 调用protoloader服务的load接口        "proto.c2s",  -- 客户端 to 服务器        "proto.s2c",  -- 服务器 to 客户端    })    local hub = skynet.uniqueservice "hub"              -- 启动hub服务    skynet.call(hub, "lua", "open", "0.0.0.0", 5678)    -- 调用hub服务中的open接口，监听5678网络端口    skynet.exit()end)

入口函数很简介，首先启动了控制台服务，该服务使得skynet在运行时，可以打印log以及信息到终端界面。

protoloader服务为proto协议的封装，注意这里的protoloader为自定义封装，而不是skynet核心代码里自带的那个。

首先调用skynetuniqueservice挂起了protoloader服务，所以接下来看看protoloader是怎么运行的。

protoloader.lua

文件路径：service/protoloader.lua

local skynet = require "skynet"local sprotoparser = require "sprotoparser" --加载skynet/lualib下的sproto解析器local sprotoloader = require "sprotoloader" --sproto加器器local service = require "service"          --加载范例根目录lualib下的servicelocal log = require "log"                  --加载范例根目录lualib下的loglocal loader = {}  --保存函数local data = {}    --保存加载后的sproto协议在skynet sprotoparser里的序号，key值为文件名local function load(name)    local filename = string.format("proto/%s.sproto", name)    local f = assert(io.open(filename), "Can't open " .. name)    local t = f:read "a"    f:close()                      --以上为读取文件内容    return sprotoparser.parse(t)    --调用skynet的sprotoparser解析sproto协议endfunction loader.load(list)    for i, namein ipairs(list) do        local p = load(name)    --加载sproto协议        log("load proto [%s] in slot %d", name, i)        data[name] = i        sprotoloader.save(p, i) --保存解析后的sproto协议    endendfunction loader.index(name)    return data[name]  --返回sproto协议在skynet sprotoloader里序号end-- 初始化服务的info信息和函数service.init {    command = loader,    info = data}

可以看到主要是定义了如何加载proto协议并保存，以及获取协议的编号(slot)，然后最后面调用了另一个lua文件的代码service.init方法。

service.lua

文件路径：lualib/service.lua

local skynet = require "skynet"local log = require "log"local service = {}-- 初始化服务，主要功能为：1：注册服务info 2：注册服务的命令函数 3：启动服务function service.init(mod)    local funcs = mod.command    if mod.infothen        skynet.info_func(function() --            return mod.info        end)        -- 这里仅作调试用，当在调试模式下，输入 “info 服务ID” 就会打印上面返回的信息        -- 调试模式的启动方法为 nc 127.0.0.1 8000    end    skynet.start(function()        if mod.require then            local s = mod.require            for _, namein ipairs(s) do                service[name] = skynet.uniqueservice(name)  --启动服务，并将该服务器保存在service下            end        end        if mod.initthen            mod.init()        end        skynet.dispatch("lua", function (_,_, cmd, ...) -- 修改lua协议的dispatch函数，对当前调用init的服务注册函数                                                        -- skynet.dispatch函数也是服务启动的结束标示            local f = funcs[cmd]    --获取命令函数            if f then                skynet.ret(skynet.pack(f(...))) --返回命令调用结果，所有通过ret的返回值都要用pack打包            else                log("Unknown command : [%s]", cmd)                skynet.response()(false)            end        end)    end)end--[[skynet.ret 在当前协程(为处理请求方消息而产生的协程)中给请求方(消息来源)的消息做回应skynet.retpack 跟skynet.ret的区别是向请求方作回应时要用skynet.pack打包]]--return service

该代码做的主要有3个工作，

• 设定当前skynet服务debug info信息
• 设定当前skynet服务在接收到其他服务调用信息时的处理，比如上一段protoloader代码中的load函数和index函数。其他服务只要发送”函数名”或者“参数”，即可调用对应的函数。其中一个值得注意的点是，skynet中服务与服务的通信必须通过 skynet.ret 和 skynet.retpack 函数进行打包和封包处理。
• 加载其他服务，并保存在service这个table中。
• 往后所有服务的代码都会通过init函数处理info信息、注册函数、加载其他服务。

回到main.lua中，可以看到调用了service.init中设定的load函数。接着挂起了hub服务。

为了不让文章变的太过冗长，下面会省略一些具体实现逻辑，主要以梳理流程为主，只有在关键点才会有详细的解释。

hub.lua

文件路径：service/hub.lua

local skynet = require "skynet"local socket = require "socket"local proxy = require "socket_proxy"    --加载范例lualib目录下的socket_proxylocal log = require "log"local service = require "service"local hub = {}  --保存函数local data = { socket = {} }    --保存监听到的链接-- 调用auth服务local function auth_socket(fd)    ...endlocal function assign_agent(fd, userid)    ...end--所有监听到的新链接都会首先交给这个函数处理function new_socket(fd, addr)    ...end--打开监听function hub.open(ip, port)    ...end--关闭监听function hub.close()    ...end--服务初始化，并挂起auth和manager服务service.init {        ...     require = {        "auth",        "manager",    }}

可以看到没有执行具体逻辑，主要以定义为主，并启动了两个服务，manager和auth。

在最开始local proxy = require “socket_proxy”中还启动了socket_proxyd服务。

不过在这边并有具体的逻辑执行，所以先不管，顺着流程继续看。

监听网络端口

回到main.lua，调用了hub服务中的open函数，开始监听网络端口。来看看该函数的具体实现。

function hub.open(ip, port)    log("Listen %s:%d", ip, port)    assert(data.fd == nil, "Already open")  --判断监听是否打开    data.fd = socket.listen(ip, port)      --新建监听端口    data.ip = ip    data.port = port    socket.start(data.fd, new_socket)      --开始监听，将监听到的链接返回到new_socket函数end

这时如果客户端发起请求，就会将监听到的链接交给new_socket函数处理

function new_socket(fd, addr)    data.socket[fd] = "[AUTH]"    proxy.subscribe(fd) --将新链接提交给socketproxy    local ok , userid =  pcall(auth_socket, fd)    if okthen        data.socket[fd] = userid        if pcall(assign_agent, fd, userid) then            return  -- succ        else            ...        end    else        ...    endend

首先调用了socket_proxy.lua中的subscribe函数

文件路径：lualib/socket_proxy.lua

function proxy.subscribe(fd)    local addr = map[fd]    if not addrthen        addr = skynet.call(proxyd, "lua", fd)  --向proxyd 发送命令，创建基于fd链接的服务，详见socket_proxyd.lua        map[fd] = addr  --保存服务地址    endend

向proxyd服务发送链接对象

文件路径：service/socket_proxyd.lua

local function subscribe(fd)    local addr = socket_fd_addr[fd]    if addrthen        return addr    --如果连接已经保存则直接返回服务ID    end    addr = assert(skynet.launch("package", skynet.self(), fd))  --创建c语言服务package（连接代理），跑当前服务(self()返回当前服务ID)，返回的是c服务的地址    socket_fd_addr[fd] = addr  --保存c服务的地址，key值为链接    socket_addr_fd[addr] = fd  --保存链接，key值为c服务的地址    socket_init[addr] = skynet.response()  --保存该链接的response函数，回应函数，这里同时会回应之前call过来的服务，告诉他addrend

这里创建了一个c语言编写的package服务，不必关心具体实现，只要知道它的功能主要是让当前链接成为一个单独的skynet服务即可，返回值是该服务的ID。

最后通过skynet.response函数返回服务ID给调用前的函数，也就是socket_proxy的subscribe。

处理链接数据

一路回到hub.lua的new_socket函数。又将链接提交给auth_socket函数

local function auth_socket(fd)    return (skynet.call(service.auth, "lua", "shakehand" , fd))end

通过service.init启动的auth服务，调用其中的shakehand函数，并发送fd链接对象。

文件路径：service/auth.lua

function auth.shakehand(fd)    local c = client.dispatch { fd = fd }  --将链接交给client对信息进行处理    return c.useridend

这里可以理解为和客户端一第次“握手”，调用client的dispatch函数，并发送链接。

文件路径：lualib/client.lua

--消息处理function client.dispatch( c )    local fd = c.fd    proxy.subscribe(fd)    local ERROR = {}    while true do        local msg, sz = proxy.read(fd)  --读取连接发来的数据        local type, name, args, response = host:dispatch(msg, sz)  --sproto解析数据        assert(type == "REQUEST")  --此处保证连接数据为请求        if c.exitthen  --exit参数为退出循环标志            return c        end        local f = handler[name]    --通过sproto解析出来的数据，获取回调函数        if f then            -- f may block , so fork and run            -- 此处创建一个协程运行回调函数            skynet.fork(function()                local ok, result = pcall(f, c, args)    -- 回调函数具体详见agent，auth，回调函数在那边实现                                                        -- 此处回调函数都为显式传参，将c显式传到回调函数中                if okthen                    proxy.write(fd, response(result))  -- 使用sproto解析出来的response函数包装返回值，并发送数据                else                    log("raise error = %s", result)                    proxy.write(fd, response(ERROR, result))                end            end)        else            -- unsupported command, disconnected            error ("Invalid command " .. name)        end    endend

这个函数为消息处理最关键的函数，所有请求都通过这里进行分发，其中回调函数都保存在handler这个table中，当前范例的回调函数都在agent.lua和，auth.lua中定义。

通过代码可以看，该函数是一个死循环，也就是说，会不断的读取客户端发送过来的信息进行处理。只有当exit变量为ture时才退出，这个exit怎么来的先不管。

接下来通过客户端发送的请求流程继续梳理。

网络请求流程

回顾下客户端的消息流程：

首先会发送signin请求，发现sign失败，用户不存在，继续发送signup请求注册用户，注册成功后再次发送signin请求，登入成功，接着会发送login请求，后面的就是正常的业务请求了。请求顺序如下：

signin > signup > signin > login > other

一步一步来，首先是signin，回到上面的dispatch，通过请求信息调用名为signin回调函数。signin的回调实现在auth.lua中

文件路径：service/auth.lua

-- signin登入请求回调function cli:signin(args)    log("signin userid = %s", args.userid)    if users[args.userid] then        self.userid = args.userid  --self为修改隐式参数        self.exit = true    --退出client中dispatch循环，表示登入成功，退出auth服务，进入下一个服务        return SUCC    else        return FAIL    endend

可以看到，当客户端第一次请求signin时，是返回失败FAIL的。这时又会回到client的dispatch函数，返回客户端注册失败消息后，继续读取链接信息。

当客户端接到signin失败后，会紧接着发送signup请求。

同样来到auth.lua

-- signup注册账号请求回调function cli:signup(args)    log("signup userid = %s", args.userid)    if users[args.userid] then        return FAIL    else        users[args.userid] = true        return SUCC    endend

这时就回返回成功，回到dispath发送注册成功消息。

接下来客户端再次发送sigin请求就会signin成功。

要注意的是，在signin回调函数中，如果signin成功则会修改exit变量，这会导致退出client的dispatch循环。为什么这里能修改exit变量呢，原因是所有回调函数都是 隐式传参 的，在函数定义中使用了“ 冒号 ”，表示隐式传送 self参数 。在dispatch中可以看到调用回调时，都会传进c变量。pcall(f, c, args)

登入成功后就会退出dispatch的循环，那么跟踪代码退到hub中的new_socket方法，发现又调用了assign_agent函数。

local function assign_agent(fd, userid)    skynet.call(service.manager, "lua", "assign", fd, userid)end

assign_gent则调用了service中保存的manager服务，同时调用manage服务中的assign方法，并传入链接对象和登入成功返回的userid。

文件路径：service/manager.lua

function manager.assign(fd, userid)    local agent    repeat        agent = users[userid]  --判断是否有当前用户的服务        if not agentthen      --若没有则创建一个            agent = new_agent()            if not users[userid] then                -- double check                users[userid] = agent            else                free_agent(agent)                agent = users[userid]            end        end    until skynet.call(agent, "lua", "assign", fd, userid)  --此处返回ture，跳出循环    log("Assign %d to %s [%s]", fd, userid, agent)end

顺着流程走，由于客户端第一次登入，会调用new_agent方法。

local function new_agent()    -- todo: use a pool    return skynet.newservice "agent"end

这里会为每个用户启动一个agent服务。

接着until中会调用该agent服务的assign方法。

文件路径：service/agent.lua

function agent.assign(fd, userid)        ...     skynet.fork(new_user, fd)    return trueend

做了很简单一件事，调用了new_user这个方法，这里要注意的是，使用了skynet.fork方法调用，该方法的作用是，不会阻塞线程，为什么要这么做接着往后看。

local function new_user(fd)    local ok, error = pcall(client.dispatch , { fd = fd })  --进入客户端消息循环，若此处客户端长时间没有任何操作，而报超时错误返回    ...end

可以看到，这里调用了client中的dispatch，前面知道该函数是个死循环，这就是为什么之前使用了skynet.fork的原因了。

好了，这样就又进入消息处理循环了，之前客户端已经发送了signin，signup，signin，这三个请求，接下来会发送login请求，去到login请求回调。该回调定义在agent.lua中。

function cli:login()    assert(not self.login)    if data.fdthen --重复登入        log("login fail %s fd=%d", data.userid, self.fd)        return { ok = false }    end    data.fd = self.fd    self.login = true    log("login succ %s fd=%d", data.userid, self.fd)    client.push(self, "push", { text = "welcome" }) -- push message to client    return { ok = true }end

主要就是调用client.push函数发送welcome信息，再来看看client中push函数的实现

function client.push(c, t, data)    proxy.write(c.fd, sender(t, data))end

调用socket_proxy中的write

function proxy.write(fd, msg, sz)    skynet.send(get_addr(fd), "client", msg, sz)end

这里用到了skynet.send函数，第一参数是服务地址，就是之前创建的package服务。

以上就是范例中服务端代码的主要逻辑。另外我对服务端代码进行了大部分注释。

链接: http://pan.baidu.com/s/1dFKD2oh 密码: rfc9