pomelo解说
nodejs+pomelo+mysql实战经验分享
Pomelo
我的仓库地址
Overview
介绍
- pomelo 是一个与以往单进程的游戏框架不同，拥有高性能，高可伸缩性，分布式多进程的游戏服务器框架。Easy configure , Easy use!
- 它包括基础开发框架和一系列相关工具和库
- pomelo-rpc,pomelo-rpc-zeromq,pomelo-scheduler,pomelo-status-plugin,bearcat,pomelo-logger,seq-queue,pomelo-cli,pomelo-robot,pomelo-admin-web
- 组成：框架，库，工具，客户端库(unity,cocos)
选择Pomelo理由
- 架构的可伸缩性好，采用多进程单进程的运行架构扩展服务器非常方便，node.js的网络io优势提供了高可伸缩性，写好的应用只需要简单地修改一下配置就能轻松地伸缩扩充
- 易用. pomelo基于轻量级的nodejs，其开发模型与web应用的开发类似，基于convention over configuration的理念， 几乎零配置， api的设计也很精简，很容易上手，开发快速
- 框架的松耦合和可扩展性好. 遵循node.js微模块的原则， 框架本身只有很少的代码，所有component、库、工具都可以用npm module的形式扩展进来，任何第三方都可以根据自己的需要开发自定义module，并把它整合到pomelo的框架中
- 完整的demo和文档. 不过要吐槽一句 坑很多 对于初次接触的人来说 ，现在基本上也没有人来维护这个框架了。而且和nodejs的版本兼容的不是太好。 Pomelo开发者群里面 经常有人问到: 你们的nodejs用的哪个版本，我的版本安装pomelo失败。
安装[node版本兼容问题 经常安装失败]
- 第一种方式
npm install pomelo -g
- 第二种方式
git clone https://github.com/NetEase/pomelo.git
cd pomelo
npm install -g
项目结构
项目创建成功后的项目结构如下图
启动
pomelo start 启动服务器
pomelo list 查看服务器状态
pomelo stop 停止应用
术语解释
gate服务器
- 负责前端的负载均衡
- 配置中 只有clientPort字段 没有port字段
- 客户端首先向gate服务器发送请求，gate会给客户端分配具体的connector服务器。具体的分配逻辑自定
- “frontend”: true
connector服务器
- 负责接收客户端的连接请求，创建与客户端的连接，维护客户端的session信息
- 接收客户端对后端服务器的请求，按照用户配置的路由策略，将请求路由给具体的后端服务器
- 扮演一个中间角色，负责接收请求，并将处理结果发送给客户端
- 配置中同时具有clientPort和port,clientPort用来监听客户端的连接，port端口用来给后端提供服务
- “frontend”: true
应用逻辑服务器
- gate服务器和connector服务器又都被称作前端服务器，应用逻辑服务器是后端服务器
- 后端服务器之间通过rpc进行交互
- 后端服务器不会和客户端有直接连接，只需监听其提供服务的端口
master服务器
- 加载配置文件，通过读取配置文件，启动所配置的服务器集群，并对所有服务器进行管理
RPC调用
- 分类: sys 系统rpc调用 和 用户自定义的rpc 调用
- sys rpc调用
- 后端向前端请求session信息
- 后端通过channel推送消息时对前端服务器发起的rpc调用
- 前端服务器将用户请求给后端服务器
- 参数
- session , args , callback
- 第一个参数session是用来做路由计算的
route router
- route用来标识一个具体服务或者客户端接受服务端推送消息的位置; 例如"chat.chatHandler.send", chat就是服务器类型，chatHandler是chat服务器中定义的一个Handler，send则为这个Handler中的一个handle方法
- 可以粗略地认为router就是根据用户的session以及其请求内容，做一些运算后，将其映射到一个具体的应用服务器id。可以通过application的route调用给某一类型的服务器配置其router
- 如果不配置的话，pomelo框架会使用一个默认的router。pomelo默认的路由函数是使用session里面的uid字段，计算uid字段的crc32校验码，然后用这个校验码作为key，跟同类应用服务器数目取余，得到要路由到的服务器编号
- 注意这里有一个陷阱，就是如果session没有绑定uid的话，此时uid字段为undefined，可能会造成所有的请求都路由到同一台服务器。所以在实际开发中还是需要自己来配置router
session sessionService
- session 是由sessionService创建
- BackendSessionService创建 BackendSession
- SessionService,FrontendSession,Session
gate session [FrontendSession]
connector session [FrontendSession]
chat session [BackendSession]
chat
channel
- 可以看作是一个玩家ID的容器，主要用于需要广播推送消息的场景，例如聊天。 个人私聊，世界频道，工会频道，都是根据channel去筛选， 要给具体的channel里的玩家推送消息
- channel 在应用服务器之前不是共享的。服务器A上创建的channel，只有服务器 A才能给它推送消息
filter
- 分类：before after
- before 对请求进行过滤 做一些前置处理 例如检测玩家session信息，以及是否登陆，以及黑名单白名单等
- after 进行请求后置处理 特殊处理 发送邮件等
handler
- 实现具体业务逻辑 在before filter和after filter之间，next回调函数串通
- msg, session, next 参数，通过next 进入到after filter处理流程
error handler
- 处理全局异常情况的地方 可发邮件通知维护
component
- pomelo 核心是由一系列松耦合的component组成
- 可自己定制component , 在服务器启动时加载，完成一定的功能
- start, afterStart, stop
- 导出工厂函数，而不是一个对象，app会将自己作为上下文信息以及后面的opts作为参数传递给这个函数，并返回一个component 对象
- app.load(componentName);
增加admin module
- 线上admin 工具
- 三主体：master,monitor,client
- 注册admin module; app.registerAdmin(moduleName,{app:app});
- moduleId , monitorHandler,masterHandler,clientHandler
register admin
process admin module
- 线上admin , client 向master服务器发送request，请求中带有moduleId和对应的回调参数
module request
热更新
- hot文件夹下
#例子
var Handler = function(app) {
this.app = app;
this.channelService = app.get('channelService');
};
var handler = Handler.prototype;
handler.send = function(msg,session,next){
next();
};
module.exports = {
id: "chatHandler",
func: Handler
};
bearcat
- context.json 配置
{
"name": "arpg_name",
"beans": [],
"scan": "app"
}
- createApp
var contextPath = require.resolve('./context.json');
bearcat.createApp([contextPath]);
bearcat.start(function() {
Configure(); //app configure
// start app
app.start();
});
pomelo服务器启动过程
启动过程
pomelo start
pomelo start 启动master服务器， master服务器调用进程创建子进程,即应用服务器
node
/app.js env=development id=connector-server-1
Application 初始化
create app 创建应用init app 初始化应用的配置信息setenv 设置环境变了
processArgs 创建应用服务器的处理过程 ， 就是上面的node …/app.js …
应用创建成功之后， 还会对app进行一些设置，比如服务器的路由设置，以及上下文变量的设置
Master服务器启动
- app.start() 后，加载默认的组件，对于master来说加载的组件为master和monitor组件
- Master组件的创建过程会创建MasterConsole, MasterConsole会创建MasterAgent, MasterAgent会创建监听Socket, 用来监听应用服务器的监控和管理请求
- 加载完组件后，会启动所有的组件。Master有自己的组件，还会启动用户自定义的Module, 在app.start()之前调用app.registerAdmin 挂在app上
- 所有的Module挂到app后，Master组件会启动MasterConsoleService.启动MasterConsoleService时，MasterConsoleService会从app处拿到所有挂在其上面的Module，然后将Module注册到自己的Module仓库中，这一步实际上就是Module放到一个以ModuleId做键的Map中，以使得后来有请求时，可以直接进行查询回调
- 然后开启MasterAgent监听，此时，Master组件就可以接受监控管理请求了
- 下一步，启动所有的Module.
- 启动所有的应用服务器。Master组件完成了所有的其自身的Module的初始化和开启任务后，Master会委托Starter完成整个服务器群的启动。 Master服务器负责管理所有应用服务器
应用服务器启动
- 参数启动
- 配置 app.configure(‘production|development’, ‘chat’,function(){…}) 配置数据库以及其他配置信息
- 细节的东西比较多 不一一讲了
服务器关闭
- pomelo stop
- 线上服务器可通过自定义Module工具停服
简单介绍完毕
到此pomelo的简单介绍算是结束了 要说的东西实在不是一句两句能说完的 大家可以去Github上去看文档
实战 [以下是我之前的项目部分代码]
app.js
var pomelo = require('pomelo');
var zmq = require('pomelo-rpc-zeromq');
var bearcat = require('bearcat');
var mysql = require('mysql');
var path = require('path');
//mysql config
var mysqlConfig = require('./config/mysql.js');
var app = pomelo.createApp();
app.set('name','appname');
//全局变量设置 有个地方会用到
global.app = pomelo.app;
//下面设置的变量 在自定义pomelo-cli工具会用到 如果不挂载在app上 其他地方引用不到
global.app.bearcat = bearcat;
global.app.async = async;
global.app.mysqlModule = mysql;
global.app.mysqlConfig = mysqlConfig;
//最重要的配置服务器
var Configure = function(){
app.configure('production|development', function () {
//todo 坑 ： 加上之后服务器启动之后 一会儿就会宕机 尚未找到原因
//app.enable('systemMonitor');
app['myLoader'] = myLoader;
app['redis'] = app.myLoader.load(__dirname + '/lib/redis.js');
//设置路由函数router
var routeUtil = app.myLoader.load(__dirname + '/app/util/route.js');
app.route('chat', routeUtil.chat);
app.route('gate', routeUtil.gate);
app.route('connector', routeUtil.connector);
app.route('data', routeUtil.data);
//全局路由过滤函数
var globalFilter = require('./app/servers/filter/globalFilter.js');
app.globalFilter(globalFilter()); //处理未登录玩家 黑名单 白名单等
//全局错误处理
var GlobalHandler = require('./app/globalHandler/globalErrorHandler.js');
var globalErrorHandler = new GlobalHandler();
app.set('globalErrorHandler',globalErrorHandler.globalHandler);
app.set('errorHandler',globalErrorHandler.globalHandler);
app.connDispatch = {};//链接调度
app.roomDispatch = {};//房间调度
//rpc client
app.set('proxyConfig', {
rpcClient: zmq.client
});
//rpc server
app.set('remoteConfig', {
rpcServer: zmq.server
});
});
//gate服务器配置
app.configure('production|development', 'gate', function () {
app.set('connectorConfig',
{
connector: pomelo.connectors.hybridconnector,
heartbeat: 8, //心跳
useDict: true,
useProtobuf: true,
disconnectOnTimeout: true 超时断开连接
});
});
//chat 服务器配置
app.configure('production|development', 'chat', function () {
});
//connector服务器配置
app.configure('production|development', 'connector', function () {
app.set('connectorConfig',
{
connector: pomelo.connectors.hybridconnector,
heartbeat: 8,
useDict: true,
useProtobuf: true,
disconnectOnTimeout : true
});
});
//data 应用服务器配置
app.configure('production|development', 'data', function () {
//配置mysql
var mysqlConf = app.myLoader.load(__dirname + '/config/mysql.js');
app['mysql'] = app.myLoader.load(__dirname + '/lib/mysql.js');
app['mysql'].config(mysqlConf);
global.app.mysql = app.mysql;
});
//master
app.configure('production|development', 'master', function() {
/＊
这里可以写一些初始化服务器的功能 比如说删除一些以前的无用信息
服务器机器人的初始化
清理redis缓存信息
等等
＊／
//清理停服状态 每次停服都是先设置状态 再主动踢出玩家
global.app.redis.get('gameServerStatus',function(){});
});
}
//use bearcat start app
var contextPath = require.resolve('./context.json');
bearcat.createApp([contextPath]);
bearcat.start(function() {
Configure();
// start app
app.start();
});
//配置日志信息格式
var logger = require('pomelo-logger').configure(path.join(app.getBase(),'/lib/log4js.json'),{base : app.getBase()});
//异常错误捕捉处理
process.on('uncaughtException',function(err){
//错误日报 发送邮件 nodemailer库
var mailModel = bearcat.getBean('sendMailModel');
mailModel.sendMail(err.stack);
});
//正式环境 去掉connsole log输出
var env = app.get('env');
if(env != 'development'){
console.log = function(){};
console.info = function(){};
console.warn = function(){};
}
配置文件
package.json 主要是版本
{
"name": "appname",
"version": "0.0.1",
"private": false,
"dependencies": {
"pomelo": "1.1.3",
"request": "2.34.0",
"zmq": "2.6.0",
"crc": "0.2.1",
"bearcat": "^0.2.37",
"pomelo-logger": "0.1.2",
"nodemailer": "1.3.0",
"nodemailer-smtp-transport": "0.1.13",
"async": "0.2.10",
"mysql": "^2.9.0", [版本问题坑过一次,老是断开连接]
"pomelo-rpc-zeromq": "0.0.8",
"redis": "0.10.0",
"redis-jsonify": "0.0.4",
"underscore": "1.7.0",
"ws": "*",
"socket.io": "0.9.17",
"pomelo-protocol": "*",
"pomelo-protobuf": "*",
"fs": "0.0.2",
"express": "^4.13.3",
"body-parser": "^1.14.1"
}
}context.json
# bearcat配置
{
"name": "appname",
"beans": [],
"scan": "app" //指的是game-server/app文件夹下的*.js
}
mysql.js
var mysql = require('mysql');
var pool;//mysql 连接池
var db = function(){
return {config : function(conf){
pool = mysql.createPool({
host : conf.host,
user : conf.user,
password : conf.password,
database : conf.database,
acquireTimeout : conf.acquireTimeout
});
pool.getConnection(function(err, connection) {
if(err){
console.log("mysql初始化失败!");
}else{
console.log("mysql初始化成功!");
connection.release();
}
});
}};
}
//
exports.mysql = function(){
return pool;
};
router函数设置
var serversConfig = require('../../config/servers.json');
exp.chat = function (route, msg, app, cb) {
var chat = app.getServersByType('chat')[0];
if (!chat) {
console.log('failed to route to chat.');
return;
}
cb(null, chat.id);
};
exp.connector = function (frontendId, msg, app, cb) {
if (!frontendId) {
console.log('failed to route to connector.');
return;
}
cb(null, frontendId);
};
//gate服务器
exp.gate = function (serverId, msg, app, cb) {
var gate = app.getServersByType('gate')[0];
if (!gate) {
console.log('failed to route to gate.');
return;
}
cb(null, gate.id);
}
/*
data 应用服务器 应用服务器的设置 可能会比较复杂一些，因为应用服务器会比gate,connector服务器要多
第一个参数session , 在我们的应用里有可能是session, characterId[string]
*/
exp.data = function (session, msg, app, cb) {
var env = app.env;
var envConfig = serversConfig[env];
var servers = envConfig['data'];
var data,index ;
var charId;
if(!!session && typeof(session) == 'object'){
if(typeof(session.get) == 'function'){
charId = session.get('character_id');
}
if(!charId){//没有角色Id的情况 : 没有登录和同步
//index = parseInt(Math.random() * servers.length);
index = servers.length - 1;
} else {
index = parseInt(charId) % servers.length ;
}
}else if(session && (typeof(session) == 'string' || typeof(session) == 'number')){
index = session % servers.length ;
}else{
index = parseInt(Math.random() * servers.length);
}
data = servers[index];
cb(null, data.id);
}
glboalErrorHandler
//错误码对照表
var errCode = require('../../lib/errCode');
如下
"chat.chatHandler.send":{
"error_code":1001 //策划填写错误提示
}
var GlobalHandler = function(app){
this.app = app;
}
var br = require('bearcat');
GlobalHandler.prototype.globalHandler = function(err, msg, resp, session, next){
var route = msg.route || msg.__route__ ;
var charId = session.get('character_id');//登陆的时候 会把角色ID放到session中
var mailModel = br.getBean('sendMailModel');
var backendSessionService = this.app['backendSessionService'];
if(err){
if('no_redis_char' == err || 'redis_err' == err){
backendSessionService.kickBySid(session.frontendId,session.id,function(err){
if(err){
mailModel.sendMail(new Error('======>>>>kick char err').stack);
}
});
}else if('update_redis_char' == err){
//更新缓存错误
backendSessionService.kickBySid(session.frontendId,session.id,function(err){
if(!err){
global.app.rpc.redis.delete('char_' + charId ,function(err){
if(err){
mailModel.sendMail(new Error('redis del charInfo err').stack);
}
});
}
});
}else if(!!errCode[route] && !!errCode[route][err]){//错误码中有对应的错误提示
next(null,{status : errCode[route][err]});
}else if(!!err['condition_lack']){
next(null,{ status : 10000 ,conditionId : err['condition_lack'].conditionId });
}else if('redis_err' == err) {
mailModel.sendMail(err.stack);
}else if(!!err.status){
next(null,err);
}else {
console.log('此错误没有对应状态码!!!!!!!!',err);
next(null,{status : 500});
}
}else{
next(null,err);
}
}
module.exports = GlobalHandler;
gate
var dispatcher = require('../../../util/dispatcher');
var pomelo = require('pomelo');
var bearcat = require('bearcat');
var async = require('async');
var util = bearcat.getBean('util');
var Handler = function() {
this.$id = 'gateHandler';
this.app = pomelo.app;
};
var handler = Handler.prototype;
handler.queryEntry = function(msg,session,next){
var self = this;
var connectors = self.app.getServersByType('connector');
if(!connectors || connectors.length === 0) {
next(null, {
status: 500
});
return;
}
async.waterfall([
function(cb){
//查看服务器是否处于停服状态 状态存储在redis缓存中 设置master时，delete掉
global.app.redis.get('gameServerStatus',function(err,data) {
if (!err && !data) {
next(null, {status: 430});
return;
}
cb(err);
});
},
function(cb){
global.app.rpc.chat.chatRemote.getOnlinePlayersNumber(null,function(err,data){
console.log('服务器同时在线人数==',data,serverLimit);
if(!err){
//查看服务器在线人数是否超过限制
if(data >= serverLimit){
next(null,{ status : 888});
return;
}
} else {
next(null,{ status : 500});
return;
}
cb();
});
}
], function (err) {
//分配一个connector服务器 ；算法是Math.random()*connectorServers.length
var res = dispatcher.dispatch(session.id,connectors);
next(null, {
status: 0,
host: res.host,
port: res.clientPort
});
});
}