pomelo之master服务器的启动



写完前面的两篇文章，一直走的都是master服务器的流程，那么这一篇就真正涉及到master服务器的启动过程了，在真正开始之前，先回顾一下前面的两篇文章。。

（1）创建app的过程，这部分主要要完成的功能是读入用户定义的配置参数，并保存和处理这些配置参数。

（2）启动app的过程，这部分主要要完成的功能是load组件，完成对组件的包装（前面已经对master组件进行了说明，在真正的master外面还有一个master的包装，代理它的启动等过程）

新来看看那个master的代理吧：

/**
 * Component for master.
 */
var Master = require('../master/master');

/**
 * Component factory function
 *
 * @param  {Object} app  current application context
 * @return {Object}      component instances
 */
 //相当于require之后得到的就是这个函数
module.exports = function (app) {
  return new Component(app);
};

/**
* Master component class
*
* @param {Object} app  current application context
*/
var Component = function (app) {
  this.master = new Master(app);   //创建爱你master
};

var pro = Component.prototype;

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

/**
 * Component lifecycle function
 *
 * @param  {Boolean}   force whether stop the component immediately
 * @param  {Function}  cb
 * @return {Void}
 */
pro.stop = function (force, cb) {
  this.master.stop(cb);
};

/**
 * Component for master.
 */
var Master = require('../master/master');

/**
 * Component factory function
 *
 * @param  {Object} app  current application context
 * @return {Object}      component instances
 */
 //相当于require之后得到的就是这个函数
module.exports = function (app) {
  return new Component(app);
};

/**
* Master component class
*
* @param {Object} app  current application context
*/
var Component = function (app) {
  this.master = new Master(app);   //创建爱你master
};

var pro = Component.prototype;

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

/**
 * Component lifecycle function
 *
 * @param  {Boolean}   force whether stop the component immediately
 * @param  {Function}  cb
 * @return {Void}
 */
pro.stop = function (force, cb) {
  this.master.stop(cb);
};

就像前面说的一样，它就是一个外包装而已。。。

那么我们来看真正的master，首先来看看真正的master的构造：

//用于创建master
var Server = function(app) {
  this.app = app;
  this.masterInfo = app.getMaster();   //master的配置实在loadMaster的配置的时候读取的，这个时候获取master的配置
  this.registered = {};   //
  this.modules = [];  //所有的模块

  //Default is the main master
  this.isSlave = false;

  this.masterConsole = admin.createMasterConsole({   //创建console
    port: this.masterInfo.port   //master的端口
  });

  if(app.enabled('masterHA')){ //Zookeeper这部分暂时先搁置，因为以前完全不了解它
    this.zookeeper = Zookeeper.getClient(app);
  }
};

//用于创建master
var Server = function(app) {
  this.app = app;
  this.masterInfo = app.getMaster();   //master的配置实在loadMaster的配置的时候读取的，这个时候获取master的配置
  this.registered = {};   //
  this.modules = [];  //所有的模块

  //Default is the main master
  this.isSlave = false;

  this.masterConsole = admin.createMasterConsole({   //创建console
    port: this.masterInfo.port   //master的端口
  });

  if(app.enabled('masterHA')){ //Zookeeper这部分暂时先搁置，因为以前完全不了解它
    this.zookeeper = Zookeeper.getClient(app);
  }
};

珍格格构造的过程看起来还是比较的简单，这里对于zookeeper的部分就先搁置，以后再来看，因为以前完全没有涉及到过zookeeper。

前面的代码要是读入master的配置信息，然后创建master的console，那么接下来来看这个console是怎么创建的吧：

module.exports.createMasterConsole = function(opts) {
    opts = opts || {};
    opts.master = true;   //用于表示当前是master服务器
    return new ConsoleService(opts);  //创建并返回console
};

module.exports.createMasterConsole = function(opts) {
	opts = opts || {};
	opts.master = true;   //用于表示当前是master服务器
	return new ConsoleService(opts);  //创建并返回console
};

好像这部分代码也没啥意思，好吧接着来看：

var ConsoleService = function(opts) {
    EventEmitter.call(this);   //让当前的对象可以处理事件
    this.port = opts.port;   //获取端口号
    this.values = {};
    this.master = opts.master;   //当前是否是master服务器

    this.modules = {};

    if(this.master) {
        this.agent = new MasterAgent(this);   //构造master agent
    } else {
        this.type = opts.type;
        this.id = opts.id;
        this.host = opts.host;
        this.agent = new MonitorAgent({
            consoleService: this,
            id: this.id,
            type: this.type,
            info: opts.info
        });
    }
};

var ConsoleService = function(opts) {
	EventEmitter.call(this);   //让当前的对象可以处理事件
	this.port = opts.port;   //获取端口号
	this.values = {};
	this.master = opts.master;   //当前是否是master服务器

	this.modules = {};

	if(this.master) {
		this.agent = new MasterAgent(this);   //构造master agent
	} else {
		this.type = opts.type;
		this.id = opts.id;
		this.host = opts.host;
		this.agent = new MonitorAgent({
			consoleService: this,
			id: this.id,
			type: this.type,
			info: opts.info
		});
	}
};

好像代码还是很简单，主要还是要创建MasterAgent，好吧，我们再来看它的创建过程吧：

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

util.inherits(MasterAgent, EventEmitter);

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

util.inherits(MasterAgent, EventEmitter);

好吧，没啥意思，那么我们接下来来看看master的start的过程吧，希望能有更多有意义的东西。。。

那么接下来来看master的start函数吧，它的代码比较长一些，需要一部分一部分的进行分析：

Server.prototype.start = function(cb) {
  registerDefaultModules(this.app);   //注册默认的modules
  loadModules(this, this.masterConsole);   //载入module

  var self = this;
  this.masterConsole.start(function(err) {   //启动console
    if(err) {
      cb(err);
      return;
    }
    startModules(self.modules, function(err) {  //启动module
      if(err) {
        cb(err);
        return;
      }
      //If it is the back up, do note start server
      if(!self.app.enabled('masterHA')){
        logger.info('masterHA not enabled, start servers');
        starter.runServers(self.app);  //启动其余的server
        cb();
      }else{
        self.zookeeper.start(function(err, result){
          if(err){
            logger.error('start zookeeper failed! err : %j', err);
            cb(err);
            return;
          }
          self.zookeeper.getLock(function(err, result){
            if(err || !result){
              self.isSlave = true;
              self.zookeeper.on('onPromote', self.onPromote.bind(self));
              cb();
            }else{
              self.zookeeper.setData(self.masterInfo, function(err){
                if(err){
                  logger.error('set master info faild!');
                  cb(err);
                  return;
                }

                starter.runServers(self.app);
                cb();
              });
            }
          });
        });
      }
    });
  });

  this.masterConsole.on('disconnect', function(id, type, reason) {  //设置disconnect事件
    crashLogger.info(util.format('[%s],[%s],[%s],[%s]', type, id, Date.now(), reason || 'disconnect'));
    var server = self.app.getServerById(id);
    if(!!server && server['auto-restart'] === 'true') {
      self.app.addServers(server);
      starter.run(self.app, server, function(err) {
        if(err) {
          cb(new Error("could not restart " + server.serverId + err), null);
          return;
        }
      });
    }
  });

  this.masterConsole.on('register', function(record) {  //register事件
    starter.bindCpu(record.id, record.pid, record.host);
  });
};

Server.prototype.start = function(cb) {
  registerDefaultModules(this.app);   //注册默认的modules
  loadModules(this, this.masterConsole);   //载入module

  var self = this;
  this.masterConsole.start(function(err) {   //启动console
    if(err) {
      cb(err);
      return;
    }
    startModules(self.modules, function(err) {  //启动module
      if(err) {
        cb(err);
        return;
      }
      //If it is the back up, do note start server
      if(!self.app.enabled('masterHA')){
        logger.info('masterHA not enabled, start servers');
        starter.runServers(self.app);  //启动其余的server
        cb();
      }else{
        self.zookeeper.start(function(err, result){
          if(err){
            logger.error('start zookeeper failed! err : %j', err);
            cb(err);
            return;
          }
          self.zookeeper.getLock(function(err, result){
            if(err || !result){
              self.isSlave = true;
              self.zookeeper.on('onPromote', self.onPromote.bind(self));
              cb();
            }else{
              self.zookeeper.setData(self.masterInfo, function(err){
                if(err){
                  logger.error('set master info faild!');
                  cb(err);
                  return;
                }

                starter.runServers(self.app);
                cb();
              });
            }
          });
        });
      }
    });
  });

  this.masterConsole.on('disconnect', function(id, type, reason) {  //设置disconnect事件
    crashLogger.info(util.format('[%s],[%s],[%s],[%s]', type, id, Date.now(), reason || 'disconnect'));
    var server = self.app.getServerById(id);
    if(!!server && server['auto-restart'] === 'true') {
      self.app.addServers(server);
      starter.run(self.app, server, function(err) {
        if(err) {
          cb(new Error("could not restart " + server.serverId + err), null);
          return;
        }
      });
    }
  });

  this.masterConsole.on('register', function(record) {  //register事件
    starter.bindCpu(record.id, record.pid, record.host);
  });
};

其实大意已经很清楚了，首先register模块，然后load模块，接着启动上面创建的console，然后再启动模块，然后再启动用户定义的其余的server，最后还要设置一些事件的处理函数。。。。

好了，那么首先来看看module的register的过程吧：

var registerDefaultModules = function(app) {
  app.registerAdmin(require('../modules/watchdog'), {app: app, master: true});
  app.registerAdmin(require('../modules/console'), {app: app, starter: starter});
  if(app.enabled('systemMonitor')) {
    app.registerAdmin(admin.modules.systemInfo);
    app.registerAdmin(admin.modules.nodeInfo);
    app.registerAdmin(admin.modules.monitorLog, {path: pathUtil.getLogPath(app.getBase())});
    app.registerAdmin(admin.modules.scripts, {app: app, path: pathUtil.getScriptPath(app.getBase())});
    if(os.platform() !== 'win32') {
      app.registerAdmin(admin.modules.profiler, {isMaster: true});
    }
  }
};

var registerDefaultModules = function(app) {
  app.registerAdmin(require('../modules/watchdog'), {app: app, master: true});
  app.registerAdmin(require('../modules/console'), {app: app, starter: starter});
  if(app.enabled('systemMonitor')) {
    app.registerAdmin(admin.modules.systemInfo);
    app.registerAdmin(admin.modules.nodeInfo);
    app.registerAdmin(admin.modules.monitorLog, {path: pathUtil.getLogPath(app.getBase())});
    app.registerAdmin(admin.modules.scripts, {app: app, path: pathUtil.getScriptPath(app.getBase())});
    if(os.platform() !== 'win32') {
      app.registerAdmin(admin.modules.profiler, {isMaster: true});
    }
  }
};

好像也没有什么意思吧，看看：

Application.registerAdmin = function(moduleId, module, opts){
  var modules = this.get('__modules__');
  if(!modules) {
    modules = [];
    this.set('__modules__', modules);
  }

  if(typeof moduleId !== 'string') {
    opts = module;   //这个是传进的参数
    module = moduleId;
    moduleId = module.moduleId;
  }

  modules.push({moduleId: moduleId, module: module, opts: opts});  //将它push进去
};

Application.registerAdmin = function(moduleId, module, opts){
  var modules = this.get('__modules__');
  if(!modules) {
    modules = [];
    this.set('__modules__', modules);
  }

  if(typeof moduleId !== 'string') {
    opts = module;   //这个是传进的参数
    module = moduleId;
    moduleId = module.moduleId;
  }

  modules.push({moduleId: moduleId, module: module, opts: opts});  //将它push进去
};

这部分其实还是相对比较的简单吧，无非是载入模块，并设置待会会用到的参数，那么接下来：

var loadModules = function(self, consoleService) {
  // load app register modules
  var modules = self.app.get('__modules__'); //获取module的信息

  if(!modules) {
    return;
  }

  var record, moduleId, module;
  for(var i=0, l=modules.length; i<l; i++){   //遍历所有的module
    record = modules[i];
    if(typeof record.module === 'function') {  //一般情况下，这里都是一个函数，因为module的定义直接弄成了一个函数，可以看成构造函数
      module = record.module(record.opts, consoleService);//可以看成调用module的构造函数
    } else {
      module = record.module;
    }

    moduleId = record.moduleId || module.moduleId;

    if(!moduleId) {
      logger.warn('ignore an uname module.');
      continue;
    }

    consoleService.register(moduleId, module);  //在console里面注册module，在console里面会将id和module关联起来保存
    self.modules.push(module);
  }
};

var loadModules = function(self, consoleService) {
  // load app register modules
  var modules = self.app.get('__modules__'); //获取module的信息

  if(!modules) {
    return;
  }

  var record, moduleId, module;
  for(var i=0, l=modules.length; i<l; i++){   //遍历所有的module
    record = modules[i];
    if(typeof record.module === 'function') {  //一般情况下，这里都是一个函数，因为module的定义直接弄成了一个函数，可以看成构造函数
      module = record.module(record.opts, consoleService);//可以看成调用module的构造函数
    } else {
      module = record.module;
    }

    moduleId = record.moduleId || module.moduleId;

    if(!moduleId) {
      logger.warn('ignore an uname module.');
      continue;
    }

    consoleService.register(moduleId, module);  //在console里面注册module，在console里面会将id和module关联起来保存
    self.modules.push(module);
  }
};

其实这部分的代码还是很简单的，首先遍历所有的module，然后调用构造函数，创建这些module，最后还要讲这些module注册到console里面去，在console里面会将这些module与其的id关联起来进行保存。。。

那么这里module的register和load过程基本就差不多了，至于说这些module有什么用，还是留到以后涉及到了再说吧。。。

好吧，我们接下来来看看console的启动过程：

ConsoleService.prototype.start = function(cb) {
    if(this.master) {
        this.agent.listen(this.port);  //监听端口
        exportEvent(this, this.agent, 'register');  //如果agent发生了register事件，那么这里也要调用一次
        exportEvent(this, this.agent, 'disconnect');
        process.nextTick(function() {
            utils.invokeCallback(cb);  //调用回调函数
        });
    } else {
        logger.info('try to connect master: %j, %j, %j', this.type, this.host, this.port);
        this.agent.connect(this.port, this.host, cb);
        exportEvent(this, this.agent, 'close');
    }

    exportEvent(this, this.agent, 'error');

    for(var mid in this.modules) {
        this.enable(mid);  //遍历并enable当前所有保存的module，在master的loadmodule的过程，会将这些module保存到console里面来
    }
};

ConsoleService.prototype.start = function(cb) {
	if(this.master) {
		this.agent.listen(this.port);  //监听端口
		exportEvent(this, this.agent, 'register');  //如果agent发生了register事件，那么这里也要调用一次
		exportEvent(this, this.agent, 'disconnect');
		process.nextTick(function() {
			utils.invokeCallback(cb);  //调用回调函数
		});
	} else {
		logger.info('try to connect master: %j, %j, %j', this.type, this.host, this.port);
		this.agent.connect(this.port, this.host, cb);
		exportEvent(this, this.agent, 'close');
	}

	exportEvent(this, this.agent, 'error');

	for(var mid in this.modules) {
		this.enable(mid);  //遍历并enable当前所有保存的module，在master的loadmodule的过程，会将这些module保存到console里面来
	}
};

这里首先会让agent来listen用户配置的master端口（socket.io），这里还有比较有意思的地方就是设置了一些事件，如果agent发生了，那么console相应的也会发生一次，类似javascript的DOM事件的冒泡的过程，从里面冒到外面来。。。估计这种设计想法也是有模仿的意思吧。。。接着在调用定义的回调函数，在回调函数中将会启动module和其余的server。。。这与说agent里的listen究竟干了些什么事情，这里也就先搁着一下吧，因为现在的所有看到的执行流程中还是没有设计到这部分。。。。

好了接下来来看看module的start过程吧：

var startModules = function(modules, cb) {
  // invoke the start lifecycle method of modules
  if(!modules) {
    return;
  }

  startModule(null, modules, 0, cb);
};

var startModule = function(err, modules, index, cb) {
  if(err || index >= modules.length) {
    cb(err);
    return;
  }

  var module = modules[index];
  if(module && typeof module.start === 'function') {
    module.start(function(err) {
      startModule(err, modules, index + 1, cb);  //我晕，这里居然还是递归的进行start
    });
  } else {
    startModule(err, modules, index + 1, cb);
  }
};

var startModules = function(modules, cb) {
  // invoke the start lifecycle method of modules
  if(!modules) {
    return;
  }

  startModule(null, modules, 0, cb);
};

var startModule = function(err, modules, index, cb) {
  if(err || index >= modules.length) {
    cb(err);
    return;
  }

  var module = modules[index];
  if(module && typeof module.start === 'function') {
    module.start(function(err) {
      startModule(err, modules, index + 1, cb);  //我晕，这里居然还是递归的进行start
    });
  } else {
    startModule(err, modules, index + 1, cb);
  }
};

好像也没啥意思吧，说白了就是调用module的start函数，然后这里有个比较有意思的就是，start的过程居然还要递归的进行，至于说为什么这样，呵呵，不知道。。

那么接下来来看是怎么进行其余的server的启动吧：

starter.runServers = function(app) {
 var servers = app.getServersFromConfig();
 for (var serverId in servers) {  //遍历所有的server
   this.run(app, servers[serverId]);  //启动server
 }
;

 starter.runServers = function(app) {
  var servers = app.getServersFromConfig();
  for (var serverId in servers) {  //遍历所有的server
    this.run(app, servers[serverId]);  //启动server
  }
};

遍历所有的server，然后启动，这里server的信息说白了就是用户定义的server，这些信息在前面已经载入了进来。。

starter.run = function(app, server, cb) {
  env = app.get('env');  //当前环境，development或者production
  var cmd, key;
  if (isLocal(server.host)) {  //host配置信息
    var options = [];
    if (!!server.args) {
      if(typeof server.args === 'string') {
        options.push(server.args.trim());
      } else {
        options.push(server.args);
      }
    }
    cmd = app.get('main');  //用于启动给的主要信息
      /*{ main: '/home/fjs/Desktop/pomelo/game-server/app.js',
  env: 'development',
  id: 'connector-server-1',
  host: '127.0.0.1',
  port: 4050,
  clientPort: 3050,
  frontend: 'true',
  serverType: 'connector' }*/
    options.push(cmd);
    options.push(util.format('env=%s',  env));  //当前的环境
    for(key in server) {  //将server的配置信息输入到命令启动行，例如host，port等
      if(key === 'cpu') {
        cpus[server['id']] = server[key];
      }
      options.push(util.format('%s=%s', key, server[key]));
    }
    starter.localrun(process.execPath, null, options, cb);  //运行命令行
  } else {
    cmd = util.format('cd "%s" && "%s"', app.getBase(), process.execPath);
    var arg = server.args;
    if (arg !== undefined) {
      cmd += arg;
    }
    cmd += util.format(' "%s" env=%s ', app.get('main'), env);
    for(key in server) {
      if(key === 'cpu') {
        cpus[server['id']] = server[key];
      }
      cmd += util.format(' %s=%s ', key, server[key]);
    }
    starter.sshrun(cmd, server.host, cb);
  }
};

starter.run = function(app, server, cb) {
  env = app.get('env');  //当前环境，development或者production
  var cmd, key;
  if (isLocal(server.host)) {  //host配置信息
    var options = [];
    if (!!server.args) {
      if(typeof server.args === 'string') {
        options.push(server.args.trim());
      } else {
        options.push(server.args);
      }
    }
    cmd = app.get('main');  //用于启动给的主要信息
      /*{ main: '/home/fjs/Desktop/pomelo/game-server/app.js',
  env: 'development',
  id: 'connector-server-1',
  host: '127.0.0.1',
  port: 4050,
  clientPort: 3050,
  frontend: 'true',
  serverType: 'connector' }*/
    options.push(cmd);
    options.push(util.format('env=%s',  env));  //当前的环境
    for(key in server) {  //将server的配置信息输入到命令启动行，例如host，port等
      if(key === 'cpu') {
        cpus[server['id']] = server[key];
      }
      options.push(util.format('%s=%s', key, server[key]));
    }
    starter.localrun(process.execPath, null, options, cb);  //运行命令行
  } else {
    cmd = util.format('cd "%s" && "%s"', app.getBase(), process.execPath);
    var arg = server.args;
    if (arg !== undefined) {
      cmd += arg;
    }
    cmd += util.format(' "%s" env=%s ', app.get('main'), env);
    for(key in server) {
      if(key === 'cpu') {
        cpus[server['id']] = server[key];
      }
      cmd += util.format(' %s=%s ', key, server[key]);
    }
    starter.sshrun(cmd, server.host, cb);
  }
};

这部分代码仿佛看起来挺复杂的，其实不然，因为大多数在前面的代码中都有涉及，无非是将要执行的命令行处理出来，然后待会用这些命令行参数来进行启动。。。那么就不细说了，直接来看localrun函数吧：

 //直接启动命令行
starter.localrun = function (cmd, host, options, callback) {
  logger.info('Executing ' + cmd + ' ' + options + ' locally');
  spawnProcess(cmd, host, options, callback);
};

 //直接启动命令行
starter.localrun = function (cmd, host, options, callback) {
  logger.info('Executing ' + cmd + ' ' + options + ' locally');
  spawnProcess(cmd, host, options, callback);
};

那么其余server的启动也就差不多了，当然这部分还有一个插曲，那就是这里server的启动还需要分时本地服务器的，还是外地服务器的，其实看代码也就启动的过程有稍微的区别，别的也都差不多，就不细说了。。。

好了，那么整个master的启动过程大概就如下：

（1）创建masterconsole

（2）创建masteragent

（3）注册以及载入module

（4）启动console
（5）启动module

（6）启动其余的server

这里有一张图感觉应该能形容master的构成：

其实也就是说master服务器大多数的功能都是通过masterconsole进行的，而masterconsole又包含一个masteragent用于监听端口，以及一些处理。。

当然至于说master服务器的具体运行原理这里文章中并没有涉及，以后会补上，因为现在确实还不知道master干些什么事情。。。