讀RILL SERVER
因為源碼是前段時間下載的，最近才拿出來分析，今天發現已經更新了，比如刪除了module中訂閱那些代碼。但是並不影響總體的思路。
他加入了behavior3 、 pl 、FSM，DDZ等等有空在分析。
有幾個維度可以分析。
- 從啟動到、消息運轉的流程
- 從skynet的關鍵函數
啟動，從service中的main啟動。然后逐個啟動service，
service啟動的時候，加載了faci下的所有文件，這個是一個服務的各項基本功能，
包括，如何從skynet接受消息，並如何分發到幾個不同實體上，dispatch forward 或者event 和 watch等。
從一次登錄消息來說，首先來到gateway，然后從faci中的dispatch，根據cmd，轉發到forward的具體函數。處理完再發回。
1 首先進入service下的main，比如開啟了 login
傳入了2個參數
local p = skynet.newservice("login", "login", i)
2 繼續將參數帶入到下個faci.service
local name, id = ...
local s = require "faci.service"
s.init(name, id)
3 這個是一個公共模塊。
然后進入faci.service,
把參數保存下來
function service.init(name, id)
env.name = name or "nameless server"
env.id = tonumber(id) or 0
end
11 然后我們看看，這個文件加載的東西，包括dispatch event module 等等。
這些模塊都是每個服務的一部分（基礎部分）。一個一個看。
首先是dispatch,終於，我們看到了他跟skynet接洽的部分，也就是，將"client"消息讓
函數：client_dispatch 處理。這個函數是系統跟 skynet的入口處。
還有一個就是，"lua"消息，由lua_dispatch處理。
skynet.dispatch("lua", lua_dispatch)
skynet.register_protocol{
name = "client",
id = skynet.PTYPE_CLIENT,
unpack = skynet.unpack,
dispatch = client_dispatch,
}
12 delicious，美味啊，來看看作者是怎么寫客戶端傳入的消息的。
hmm。。似乎多了一個check？先不管他。
get_queue_id(cmd) 得到 CMD的對應編號；
為每個fd，建立了一個等待隊列
該隊列下，對應的命令也初始化下。env.waiting_queue[fd][queue_id] = {}
function client_dispatch(session, source, fd, cmd, check, msg)
local queue_id = get_queue_id(cmd) -- get_queue_id(cmd) 得到 CMD的對應編號；
if not queue_id then -- 如果指令不需要排隊則直接執行
client_dispatch_help(cmd, check, msg, fd, source)
return
end
if not env.waiting_queue[fd] then
env.waiting_queue[fd] = {} --為每個fd，建立了一個等待隊列
end
if not env.waiting_queue[fd][queue_id] then
env.waiting_queue[fd][queue_id] = {} --該隊列下，對應的命令也初始化下
end
local queues = env.waiting_queue[fd][queue_id]
if #queues > 0 then -- 如果有未完成的任務則插入后直接返回。
table.insert(queues, {cmd, check, msg, fd, source})
return
end
-- 如果沒有則直接進入后執行
table.insert(queues, {cmd, check, msg, fd, source})
for i = 1, 100 do
local queue = table.remove(queues)
if not queue then
return
end
client_dispatch_help(table.unpack(queue))
end
if #queues > 0 then -- 如果執行到這，也就是隊列超過100個則拋棄該FD的該指令隊列
log.error("%s queue is full, queue_id: %d", fd, queue_id)
end
env.waiting_queue[fd][queue_id] = nil
end
13 繼續看指令的拆分和執行,拆分CMD中的
local function client_dispatch_help(cmd, check, msg, fd, source)
msg._cmd = cmd
msg._check = check
--TODO check校驗
local cmdlist = string.split(cmd, ".")
local isok, ret
--派發到本服
isok, ret = local_dispatch(cmdlist[1], cmdlist[2], fd, msg, source)
--派發到遠端
if not isok then
isok, ret = romote_dispatch(cmdlist[1], cmdlist[2], fd, msg, source)
end
if ret then
skynet.send(source, "lua", "send", fd, ret)
end
end
14 local_dispatch中cmd1應該是模塊名，比如login/game，cmd2，是具體的指令，比如是msgLogin這種。
注意，本地是調用forward的上的名為cmd2方法。
遠程的話需要額外知道，player.romote[cmd1]，也就是玩家的遠程服務的地址。
function local_dispatch(cmd1, cmd2, fd, msg, source)
local module = env.module[cmd1]
if type(module) ~= "table" then
log.info("local_dispatch module is not table, cmd = %s.%s, msg = %s", cmd1, cmd2, tool.dump(msg))
return false
end
local forward = module.forward
if type(forward) ~= "table" then
log.info("local_dispatch forward is not table, cmd = %s.%s, msg = %s", cmd1, cmd2, tool.dump(msg))
return false
end
local cb = forward[cmd2]
if type(cb) ~= "function" then
log.info("local_dispatch cb is not function, cmd = %s.%s, str = %s", cmd1, cmd2, tool.dump(msg))
return false
end
--開始分發
local v = get_v(fd)
local isok, ret = xpcall(cb, traceback, v, msg, source)
if not isok then
log.error("local_dispatch handle msg error, cmd = %s, msg = %s, err=%s", cmd1, tool.dump(msg), ret)
return true --報錯的情況也表示分發到位
end
return true, ret
end
15 在看內部的消息轉發 lua_dispatch,但是接受3種保留類型，
其他的消息都通過dispatch來做，跟上面通過forward類似，各自處理一類消息。
（類似CMD和 request）
watch 和 sys 消息類型不太明白
local function lua_dispatch(session, addr, cmd, ...)
local cmdlist = string.split(cmd, ".")
local cmd1 = cmdlist[1]
local cmd2 = cmdlist[2]
--forward分發
if cmd1 == "client_forward" and not cmd2 then
local isok, msg = local_dispatch(...)
skynet.retpack(isok, msg)
return true
elseif cmd1 == "watch" and not cmd2 then
local isok, msg, acm = watch(...)
skynet.retpack(isok, msg, acm)
return true
elseif cmd1 == "sys" then
local isok, msg = sys_dispatch(cmd2, ...)
skynet.retpack(isok, msg)
return true
end
--模塊
local module = env.module[cmd1]
if type(module) ~= "table" then
log.info("lua_dispatch module is not table, cmd = %s.%s", cmd1, cmd2)
skynet.ret()
return false
end
local dispatch = module.dispatch
if type(dispatch) ~= "table" then
log.info("lua_dispatch dispatch is not table, cmd = %s.%s", cmd1, cmd2)
skynet.ret()
return false
end
local cb = dispatch[cmd2]
if type(cb) ~= "function" then
log.info("lua_dispatch cb is not function, cmd = %s.%s", cmd1, cmd2)
skynet.ret()
return false
end
--分發
local function skyret(ok, ...)
if not ok then
skynet.ret()
else
skynet.retpack(...)
end
end
local ret = {xpcall(cb, traceback, ...)}
local isok = ret[1]
if not isok then
log.info("lua_dispatch cb call fail, cmd = %s.%s, err = %s", cmd1, cmd2, ret)
skynet.ret()
return false
end
skyret(table.unpack(ret))
end
16 一個 watch 的例子,供其他模塊查看該模塊內部的情況
function module.watch(acm)
--統計在線人數
local logined = 0 --成功登陸
for i, v in pairs(env.players) do
logined = logined + 1
end
local ret = {logined = logined}
--總統計
acm.logined = acm.logined and acm.logined + logined or logined
return ret, acm
end
17 sys的命令通過dispatch執行，熱更新reload和stop。
18 再看看事件機制。假設有2個節點A 和B
A要訂閱B，就調用module中的subscribe_event,
提供以下細信息：要訂閱的事件，要訂閱的節點，目標服務
function M.subscribe_event(event, nodename, service, key)
local local_service = skynet.self()
if nodename == local_nodename then
return skynet.call(service, "sys.subscribe_event", event, local_nodename, local_service, key)
end
return cluster.call(nodename, service, "sys.subscribe_event", event, local_nodename, local_service, key)
end
此時，B收到這個訂閱消息，這樣處理
local sys = {
}
function sys.subscribe_event(event, nodename, service, key)
faci._subscribe_event(event, nodename, service, key)
return true
end
--上在DISPATH文件，下在MODULE中
function M._subscribe_event(event, nodename, service, key)
if not env.events[event] then
env.events[event] = {}
end
if not env.events[event][nodename] then
env.events[event][nodename] = {}
end
if not env.events[event][nodename][service] then
env.events[event][nodename][service] = {}
end
if not env.events[event][nodename][service][key] then
env.events[event][nodename][service][key] = {}
end
env.events[event][nodename][service][key] = true
end
事件的觸發
local event_cache = {}
function M.fire_event(name, ...)
--獲取列表
local cache = event_cache[name]
if not cache then
event_cache[name] = {}
for i, v in pairs(env.module) do
if type(v.event[name]) == "function" then
table.insert(event_cache[name], v.event[name])
end
end
end
cache = event_cache[name]
--執行
for _, fun in ipairs(cache) do
log.info("fire event %s", name)
xpcall(fun, function(err)
log.error(tostring(err))
log.error(debug.traceback())
end, ...)
end
--遠程事件
local events = env.events[name]
if not events then
return
end
for nodename, nodes in pairs(events) do
for service, keys in pairs(nodes) do
if nodename == localname then
skynet.send(service, name, keys, ...)
else
cluster.send(nodename, service, name, keys, ...)
end
end
end
end
4 servive中，然后進入start
skynet.start(function()
init()
if env.init then
env.init()
end
end)
5 看看init，將傳遞的name命名到該服務，設置他的全局變量。
初始化模塊的相關東西。
啟動了事件，喚醒和開始？
local function init()
--名字和編號
local name = env.name
local id = env.id
if not name then
return
end
--命名
local idstr = env.id > 0 and tostring(env.id) or ""
local name = string.format("%s%s", name, idstr)
skynet.name(name, skynet.self())
--設置
log.set_name(name)
--全局變量
_G["env"] = env
_G["log"] = log
--模塊
module.init_modules()
module.fire_event("awake")
module.fire_event("start")
log.debug("start ok "..name.."...")
end
6 看看這個module.init_modules()
function M.init_modules()
require_modules()
end
7 繼續跟蹤,牛皮，加載了根目錄+mod+文件名（login）下的所有lua，直接require
在項目中，是2個文件login_forward.lua 和 login_mode_test.lua
local function require_modules()
local path = skynet.getenv("app_root").."mod/"..env.name
lfstool.attrdir(path, function(file)
local file = string.match(file, ".*mod/(.*)%.lua")
if file then
log.info(string.format("%s%d require file:%s", env.name, env.id, file))
require(file)
end
end)
end
8 回去繼續看 module.fire_event("awake")
從上下文理解，這個應該是啟動call event ，awake 不是解雇。
這里沒太明白，大致意思應該是，凡是注冊過該節點的awake的都會調用，包括本地和遠程。
local event_cache = {}
function M.fire_event(name, ...)
--獲取列表
local cache = event_cache[name]
if not cache then
event_cache[name] = {}
for i, v in pairs(env.module) do
if type(v.event[name]) == "function" then
table.insert(event_cache[name], v.event[name])
end
end
end
cache = event_cache[name]
--執行
for _, fun in ipairs(cache) do
log.info("fire event %s", name)
xpcall(fun, function(err)
log.error(tostring(err))
log.error(debug.traceback())
end, ...)
end
--遠程事件
local events = env.events[name]
if not events then
return
end
for nodename, nodes in pairs(events) do
for service, keys in pairs(nodes) do
if nodename == localname then
skynet.send(service, name, keys, ...)
else
cluster.send(nodename, service, name, keys, ...)
end
end
end
end
9 再回去看加載的那些,7.
這2個東西應該比較重要，一個是模塊，一個是全局變量。
先看看這個函數get_module
local module, static = faci.get_module("Login")
10 在文件module中,這里給出了每個模塊的4個基本動作
dispatch ， forward ， event， watch
dispatch是本文件處理的，這個是skynet必備的。其他三個可能是作者自己加的？
local module = {}
function M.get_module(name)
--模塊處理函數
env.module[name] = env.module[name] or {
dispatch = {},
forward = {},
event = {},
watch = nil,
}
--模塊全局變量
env.static[name] = env.static[name] or {
}
return env.module[name], env.static[name]
end