源码分为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下的service
local log = require "log" --加载范例根目录lualib下的log
local 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协议
end
function 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协议
end
end
function 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_proxy
local log = require "log"
local service = require "service"
local hub = {} --保存函数
local data = { socket = {} } --保存监听到的链接
-- 调用auth服务
local function auth_socket(fd)
...
end
local 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
...
end
end
首先调用了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 --保存服务地址
end
end
向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过来的服务，告诉他addr
end
这里创建了一个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.userid
end
这里可以理解为和客户端一第次“握手”，调用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
end
end
这个函数为消息处理最关键的函数，所有请求都通过这里进行分发，其中回调函数都保存在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
end
end
可以看到，当客户端第一次请求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
end
end
这时就回返回成功，回到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 true
end
做了很简单一件事，调用了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
扩展阅读
原创文章，转载请注明：转载自Tshine's Blog
本文链接地址: skynet范例研究-服务端
1291
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
