pomelo源码分析（四）

接着上文，上文利用提到程序利用

this._optComponents('start', function(err) {
self.state = STATE_START;
utils.invokeCallback(cb, err);
});

发送命令让刚配置好的服务器模块，执行start命令，现在我们开始分析master.start();

lib/components/master.js

var Master = require('../master/master');

var pro = Component.prototype;

/**
* Component lifecycle function
*
* @param  {Function} cb
* @return {Void}
*/
pro.start = function (cb) {
this.master.start(cb);
};

var Master = require('../master/master');

初始化Master模块

module.exports = Server;

var Server = function(app) {
this.app = app;
this.masterInfo = app.get('master');  //获取master的服务器信息，前文有介绍，从master.json文件里面 ，defaultConfiguration函数里
this.registered = {};

this.masterConsole = admin.createMasterConsole({ //创建一个MasterConsole
port: this.masterInfo.port
});
};

adminConsole 有三种角色，分别是 master,monitor,client

master : 运行在master进程中，监听端口等待monitor和client的连接。主要负责维护所有已注册的连接，消息路由和处理，以及缓存服务器集群状态信息。
monitor : 运行在各个需要监控的服务器进程中（包括master进程）。启动后连接并注册到master，主要负责收集被监控的进程信息，向master汇报。
client : 运行在admin console的web页面。启动后连接并注册到master。主要负责响应用户操作和呈现master返回结果。

其实，此代码写得是masterconsole.主要负责维护所有已注册的连接，消息路由和处理，以及缓冲服务器集群的状态信息

pomelo/node_modules/pomelo-admin/lib/consoleServer.js

/**
* Create master ConsoleService
*
* @param {Object} opts construct parameter
*                      opts.port {String | Number} listen port for master console
*/
module.exports.createMasterConsole = function(opts) {
opts = opts || {};
opts.master = true;  //标记为master服务器
return new ConsoleService(opts);  //根据opts.master 的标记来决定初始化master服务器或monitor服务器，创建consoleService,并返回
};

创建consoleService对象

/**
* ConsoleService Constructor
*
* @class ConsoleService
* @constructor
* @param {Object} opts construct parameter
*                      opts.type {String} server type, 'master', 'connector', etc.
*                      opts.id {String} server id
*                      opts.host {String} (monitor only) master server host
*                      opts.port {String | Number} listen port for master or master port for monitor
*                      opts.master {Boolean} current service is master or monitor
* @api public
*/
var ConsoleService = function(opts) {
EventEmitter.call(this);  //ConsoleService继承EventEmitter 方法
this.port = opts.port;  //设置master服务器端口
this.values = {};
this.master = opts.master;  //服务器类型标记，true为master ，其余为monitor

this.modules = {};

if(this.master) {
this.agent = new MasterAgent(this);  //创建MasterAgent 对象
} else {
this.type = opts.type;
this.id = opts.id;
this.host = opts.host;
this.agent = new MonitorAgent({      //创建MonitorAgent对象
consoleService: this,
id: this.id,
type: this.type
});
}
};

util.inherits(ConsoleService, EventEmitter); //在ConsoleService下，创建super_ 属性 指向EventEmitter

这里涉及的概念主要有2个，第一个consoleService继承node.js的事件方法，第二个创建MasterAgent或MonitorAgent。

第一，consoleService继承node.js的事件方法

EventEmitter.call(this); //ConsoleService继承EventEmitter 方法 ，可以 使用 this.emit方法 和 一些事件的监听，如下

this.masterConsole.on('register', function(record) {
logger.debug('[master] new register connection: %j, %j', record.id, record.type);
self.registered[record.id] = record;
if(checkRegistered(self)) {
logger.info('[master] all servers have started and notify after start now...');
self.masterConsole.agent.notifyAll(AfterStart.moduleId);
}
});

util.inherits() node.js的util提供的方法 http://docs.cnodejs.net/cman/util.html#util_
util.inherits(constructor, superConstructor)

Inherit the prototype methods from one constructor into another. The prototype of constructor will be set to a new object created from superConstructor.

将一个构造函数的原型方法继承到另一个构造函数中。constructor构造函数的原型将被设置为使用superConstructor构造函数所创建的一个新对象。

As an additional convenience, superConstructor will be accessible through the constructor.super_ property.

此方法带来的额外的好处是，可以通过constructor.super_属性来访问superConstructor构造函数。

var util = require("util");
var events = require("events");

function MyStream() {
events.EventEmitter.call(this);
}

util.inherits(MyStream, events.EventEmitter);

MyStream.prototype.write = function(data) {
this.emit("data", data);
}

var stream = new MyStream();

console.log(stream instanceof events.EventEmitter); // true
console.log(MyStream.super_ === events.EventEmitter); // true

stream.on("data", function(data) {
console.log('Received data: "' + data + '"');
})
stream.write("It works!"); // Received data: "It works!"

第二，MasterAgent和MonitorAgent作用

consoleService,是整个监控模块的总入口，master和monitor上都需要创建。各个进程向consoleService注册各自的module。ConsoleService根据当前服务器类型，创建底层的agent实例，并负责agent的启动和关闭。consoleService同时也充当了map的角色，缓存收集到的状态信息。
masterAgent,在master进程中启动，负责底层网络通讯相关工作。如：监听端口，接收monitor和client连接，分组维护这些连接以及将消息推送给指定的接收者等。
monitorAgent,在各个需要监控进程中启动（包括master进程）。启动后连接并注册到masterAgent，负责与masterAgent之间的通讯。
module,监控模块接口，实现监控相关的具体逻辑。定义三个回调接口，分别对应于master，monitor和client上的逻辑。

接下来，我们继续看ConsoleService 里会初始化一个MasterAgent

MasterAgent

if(this.master) {
this.agent = new MasterAgent(this);
}

var MasterAgent = function(consoleService) {
EventEmitter.call(this);
this.consoleService = consoleService;
this.server = null;
this.idMap = {};
this.typeMap = {};
this.clients = {};
this.reqId = 1;
this.callbacks = {};
this.state = ST_INITED;
};

MonitorAgent

this.type = opts.type;
this.id = opts.id;
this.host = opts.host;
this.agent = new MonitorAgent({
consoleService: this,
id: this.id,
type: this.type
});

var MonitorAgent = function(opts) {
EventEmitter.call(this);
this.consoleService = opts.consoleService;
this.id = opts.id;
this.type = opts.type;
this.socket = null;
this.reqId = 1;
this.callbacks = {};
this.state = ST_INITED;
};

总结一下流程，代码需要执行master.start()的时候，需要对master进行初始化，初始化的过程中，会初始化createMasterConsole -> 初始化ConsoleService并返回-> 初始化MasterAgent。ConsoleService相当于agent的总代理，我们有事情就找ConsoleService，consoleservice会找到合适的对象去处理。