Skynet源码之：节点建立(5)

static unsigned int HARBOR = ~0; // 全局声明

void
skynet_harbor_init(int harbor) {
    // 把配置config中的 harbor 向左移动24位，harbor作为服务的节点标记
    // 参看《Skynet源码之：服务管理》中，skynet_handle_register函数，当中也有对服务handle中harbor的操作
	HARBOR = (unsigned int)harbor << HANDLE_REMOTE_SHIFT; // HANDLE_REMOTE_SHIFT == 24
}

void 
skynet_harbor_send(struct remote_message *rmsg, uint32_t source, int session) {
	assert(invalid_type(rmsg->type) && REMOTE);
	skynet_context_send(REMOTE, rmsg, sizeof(*rmsg) , source, PTYPE_SYSTEM , session); // 把这个消息发往外部节点
}

int 
skynet_harbor_message_isremote(uint32_t handle) {
	assert(HARBOR != ~0);
	int h = (handle & ~HANDLE_MASK);
	return h != HARBOR && h != 0;
}

static struct skynet_context * REMOTE = 0; // 全局声明一个服务

// 在skynet_harbor_start()被赋值
void
skynet_harbor_start(void *ctx) {
	// the HARBOR must be reserved to ensure the pointer is valid.
	// It will be released at last by calling skynet_harbor_exit
	skynet_context_reserve(ctx);
	REMOTE = ctx; // REMOTE被赋值
}

int
harbor_init(struct harbor *h, struct skynet_context *ctx, const char * args) {
	h->ctx = ctx;
	int harbor_id = 0;
	uint32_t slave = 0;
	sscanf(args,"%d %u", &harbor_id, &slave);
	if (slave == 0) {
		return 1;
	}
	h->id = harbor_id;
	h->slave = slave;
	if (harbor_id == 0) {
		close_all_remotes(h);
	}
	skynet_callback(ctx, h, mainloop);
	skynet_harbor_start(ctx); // 最终在这里调用 skynet_harbor_start()

	return 0;
}

// 1，bootstrap服务 --> cdummy服务 --> harbor服务
// 如果配置cluster模式，即配置harbor = 0，不配置standalone，master，address的值 
// 在skynet第二个启动的bootstrap服务中，第一位是log服务
// 除了第三个启动 launcher 服务外，还启动了 cdummy 服务
// 而 cdummy 服务就会启动 harbor
harbor_service = assert(skynet.launch("harbor", harbor_id, skynet.self()))

// 2，bootstrap服务 --> cslave服务 --> harbor服务
// 如果配置master-slave模式，即配置harbor = 1，standalone，master，address也有值
// 在启动的cslave服务中，也会启动harbor服务
harbor_service = assert(skynet.launch("harbor", harbor_id, skynet.self()))

// 现在 REMOTE 的值也明显了
// REMOTE 的值就是刚启动的harbor服务

int
skynet_send(struct skynet_context * context, uint32_t source, uint32_t destination, int type, int session, void * data, size_t sz) {
    // ...代码省略...
    
    // 检查消息是不是发给远程的
	if (skynet_harbor_message_isremote(destination)) { // 如果是发给远程的，需要构造新的remote_message结构
        // 结构体 remote_message 在 skynet_harbor.h 中定义
		struct remote_message * rmsg = skynet_malloc(sizeof(*rmsg));
		rmsg->destination.handle = destination;
		rmsg->message = data;
		rmsg->sz = sz & MESSAGE_TYPE_MASK;
		rmsg->type = sz >> MESSAGE_TYPE_SHIFT;
		skynet_harbor_send(rmsg, source, session);
	} else { // 发给本地的消息处理
		// ...代码省略...
	}
}
// 最后等于说：如果检查到这个消息是发给外部节点的，就会经过struct remote_message包装后
// 通过skynet_harbor_send()发给 harbor 服务
// 最后由 harbor 服务统一发送消息给外部节点

skynet.start(function()
	local standalone = skynet.getenv "standalone" -- 获取 standalone 的值，但是我们没有配置，会返回 nil
    
    -- launcher 服务的内容，详细请看《Skynet源码之：service_snlua》中第7点
	local launcher = assert(skynet.launch("snlua","launcher")) -- 启动 launcher 服务
	skynet.name(".launcher", launcher) -- 命名 launcher 服务为 ".launcher"
	
	local harbor_id = tonumber(skynet.getenv "harbor" or 0) -- 获取 harbor 的值，如果没有就默认为 0
    
    -- 下面我们主要关注 harbor 为 0 的情况
	if harbor_id == 0 then
        -- 确定 standalone 为 nil 之后，把 standalone 设置为 true
        -- 作用是：需要启动 datacenterd 服务，待会后面可以看到
		assert(standalone == nil)
		standalone = true
		skynet.setenv("standalone", "true")
		
		local ok, slave = pcall(skynet.newservice, "cdummy") -- 这里启动了 cdummy 服务，让我们看看代码段1，详细了解
		if not ok then
			skynet.abort()
		end
		skynet.name(".cslave", slave) -- 这里就给 slave 服务进行了命名，让我们看看代码段2，详细了解
	
	else
		-- 我们先不关心 master-slave 模式
	end
        
    -- 可以看到：
    -- 		假如你是命名 ".cslave" 这种本地名字，skynet.name() 会给 服务管理handle_storage 发送消息进行本地节点服务-名字的绑定
    -- 		假如你是命名 "DATACENTER" 这种全局名字，skynet.name() 会给 ".cslave" 发送消息进行服务-名字的绑定
    --        		 	而所谓的 ".cslave" 其实就是 cdummy 服务
    --
    -- 即开启 cdummy 服务，在本地节点命名为 .cslave，因为本地命名是通过 服务管理handle_storage 实现的
    -- 当 cdummy 服务启动并被命名为 .cslave，可以注册全局名字，此时会向 cdummy 服务发送信息进行绑定
    
	if standalone then
		local datacenter = skynet.newservice "datacenterd"
		skynet.name("DATACENTER", datacenter)
	end
	skynet.newservice "service_mgr"
	
	-- ...代码省略...

end)

-- cdummy.lua 文件中的部分代码
skynet.start(function()
	local harbor_id = tonumber(skynet.getenv "harbor") -- 获取 harbor 的值
	assert(harbor_id == 0) -- 检查 harbor 的值，确保是 0

	skynet.dispatch("lua", function (session,source,command,...)
		local f = assert(harbor[command])
		f(...)
	end)
	skynet.dispatch("text", function(session,source,command)
		-- ignore all the command
	end)
	
	harbor_service = assert(skynet.launch("harbor", harbor_id, skynet.self())) -- 在这里开启 harbor 服务
end)

-- 下面我们看下 cdummy 服务有什么命令

-- 绑定 名字-服务handle 的关系，即注册全局服务名字
function harbor.REGISTER(name, handle)
end

-- 根据 名字 查询服务handle
function harbor.QUERYNAME(name)
end

function harbor.LINK(id)
end

function harbor.CONNECT(id)
	-- skynet.error("Can't connect to other harbor in single node mode")
end

-- manager.lua 文件中的部分代码
function skynet.name(name, handle)
	if not globalname(name, handle) then -- 判断是不是注册全局名字
		c.command("NAME", name .. " " .. skynet.address(handle)) -- 进行本地名字注册
	end
end

-- 全局名字注册 的判断函数
local function globalname(name, handle)
	local c = string.sub(name,1,1) -- 抓取 name 的第一个字符
	assert(c ~= ':') -- 如果是 : 开头，则直接报错
	if c == '.' then -- 如果是 . 开头，表示要注册的是本地节点名字，返回false
		return false
	end

    -- 下面就是全局名字的注册流程
    
	assert(#name < 16)	-- GLOBALNAME_LENGTH is 16, defined in skynet_harbor.h
	assert(tonumber(name) == nil)	-- global name can't be number

	local harbor = require "skynet.harbor"

	harbor.globalname(name, handle) -- 给 harbor 服务发消息，要注册全局名字

	return true
end

-- 注册全局名字
-- skynet/lualib/skynet/harbor.lua的部分代码
function harbor.globalname(name, handle)
	handle = handle or skynet.self()
	skynet.send(".cslave", "lua", "REGISTER", name, handle)
end

-- 本地名字和全局名字的区别
--
-- 本地名字，就是发送 .name 和 handle 给服务管理模块，在handle_storage中绑定本地服务id和名字的关系
-- 全局服务，就是发送 NAME 和 handle 给服务cslave，服务cslave本质就是cdummy.lua，实质就是harbor c服务
--
-- 当别的节点发送消息过来，或者，要往别的节点发送消息，就需要通过harbor服务来实现

-- 特别注意，按流程：
-- 		local ok, slave = pcall(skynet.newservice, "cdummy")
-- 		skynet.name(".cslave", slave)
-- 		globalname(name, handle)
-- 而 globalname(name, handle) 最终又会调用：
-- 		skynet.send(".cslave", "lua", "REGISTER", name, handle)
--
-- 这就要求：一定要先完成 skynet.name(".cslave", slave) 本地服务的注册，才能根据本地服务名字来使用.cslave服务
-- 像后面的 skynet.name("DATACENTER", datacenter) 就是在 skynet.name(".cslave", slave) 完成之后的

-- 显然，一开始的 globalname(name, handle) 即 globalname(".cslave", handle) 会返回 false
-- 此时进入 c.command("NAME", name .. " " .. skynet.address(handle)) 的代码
-- 详细看代码段3

// 最终会调用到 c 层面的函数
static const char *
cmd_name(struct skynet_context * context, const char * param) {
	int size = strlen(param);
	char name[size+1];
	char handle[size+1];
	sscanf(param,"%s %s", name, handle);
	if (handle[0] != ':') {
		return NULL;
	}
	uint32_t handle_id = strtoul(handle+1, NULL, 16);
	if (handle_id == 0) {
		return NULL;
	}
	if (name[0] == '.') {
		return skynet_handle_namehandle(handle_id, name + 1); // 调用名字-handle绑定的函数，详细请看《Skynet源码之：服务管理》
	} else {
		skynet_error(context, "Can't set global name %s in C", name);
	}
	return NULL;
}