pomelo记录一

最新推荐文章于 2020-12-23 07:36:03 发布

超級码力

最新推荐文章于 2020-12-23 07:36:03 发布

阅读量2.5k

点赞数

分类专栏： pomelo

本文链接：https://blog.csdn.net/u010223072/article/details/107448685

版权

pomelo 专栏收录该内容

29 篇文章 5 订阅

订阅专栏

减少消息数量 — 消息只发送给能看到的玩家。玩家能看到的只是屏幕的大小，而不是整张地图的大小，这样推送消息的时候可以只推给对自己的状态感兴趣的玩家。这个可以用 AOI（area of interested）算法来实现，在 pomelo 的库 pomelo-aoi 中实现了简单的灯塔算法。
尽量分进程，进程的粒度越少，出现 tick 超时或 full GC 的可能越少，一定要控制内存大小。在多核时代里，CPU 是最廉价的资源。
常规MMO游戏服务器架构：

运行架构说明：

客户端通过 websocket 长连接连到 connector 服务器群。
connector 负责承载连接，并把请求转发到后端的服务器群。
后端的服务器群主要包括按场景分区的场景服务器 (area)、聊天服务器 (chat) 和状态服务器等 (status)，这些服务器负责各自的业务逻辑。真实的案例中还会有各种其它类型的服务器。
后端服务器处理完逻辑后把结果返回给 connector，再由 connector 广播回给客户端。 master 负责统一管理这些服务器，包括各服务器的启动、监控和关闭等功能。

在 pomelo 中 session 也是 key/value 对象，其主要作用是维护当前用户信息，例如：用户的 id，所连接的前端服务器 id 等。session 由前端服务器维护，前端服务器在分发请求给后端服务器时，会复制 session 并连同请求一起发送。任何直接在 session 上的修改，只对本服务器进程生效，并不会影响到用户的全局状态信息。如需修改全局 session 里的状态信息，需要调用前端服务器提供的 RPC 服务。
下图是 pomelo 最初的组成图：

pomelo 包括以下几部分:

框架, 框架是 pomelo 最核心的部分。
库，pomelo 提供了很多库，有些是跟游戏逻辑完全相关的，如 AI ， AOI ，寻路等；也有与游戏逻辑无关的，如定时任务执行，数据同步。
工具，pomelo 提供了管理控制台、命令行工具、压力测试工具等一系列工具。
各类客户端， pomelo 提供了各类平台的客户端，包括 js, C, android, iOS, unity3d 等，这些都可以从 pomelo 的官方主页查到。
Demo，一个框架需要强大的 demo 来展示功能，pomelo 提供了全平台的聊天 demo 和基于HTML5 的捡宝Demo ，系统还提供了一个强大的基于HTML5 开发的强大的MMO 游戏demo Lord Of Pomelo 。
而最妙的地方在于所有这些组件都是松耦合的，所有这些组件都可以独立使用。

6.支持动态增加和移除服务器进程机制，并提供相应的命令行工具。但由此而导致的路由规则的变化应当由具体的应用自己来维护。

//动态添加服务器
pomelo add host=[host] port=[port] id=[id] serverType=[serverType]
//动态移除服务器
pomelo stop [id]

master服务器的高可用(pomelo-masterha-plugin或者 pomelo-zookeeper-plugin)。master高可用采用多机热备技术，采用主Master+多个备份Master节点的方式实现高可用。当主master宕机时，某一个从master会自动接管主master的工作，并与其他服务器建立连接，继续提供服务，这一过程全部是自动进行的。
在Pomelo0.5版本中增加了服务器（非master）自动重启的功能，服务器的自动重启是以服务器与master服务器的连接状态为判断依据，即当服务器与master服务器断开后触发该服务器的重新启动。建议只对无状态的服务器配置自动重启，这样能够保证服务器重启后不影响原系统的运行。默认情况下服务器不会自动重启，如果需要开启自动重启功能需要在servers.json中进行配置auto-restart，具体配置如下：

{
    "development":{
        "connector":[
            {"id":"connector-server-1", "host":"127.0.0.1", "port":4050, "clientPort": 3050, "frontend": true}
         ]
        "chat":[
           {"id":"chat-server-1", "host":"127.0.0.1", "port":6050, "auto-restart": true}
        ]
        "gate":[
	   {"id": "gate-server-1", "host": "127.0.0.1", "clientPort": 3014, "frontend": true}
	]
    }
}

Pomelo在0.5版本中增加了服务器进程与指定CPU进行绑定，该功能限于linux系统的多核服务器，如果需要将服务器与具体CPU进行绑定，只需要在servers.json中进行配置，具体配置如下：

{
    "development":{
        "connector":[
             {"id":"connector-server-1", "host":"127.0.0.1", "port":4050, "clientPort": 3050, "frontend": true, "cpu": 2}
         ]
        "chat":[
             {"id":"chat-server-1", "host":"127.0.0.1", "port":6050, "cpu": 1}
        ] 
        "gate":[
	     {"id": "gate-server-1", "host": "127.0.0.1", "clientPort": 3014, "frontend": true, "cpu": 3}
	]
     }
}

为了让开发者能够在服务器关闭前自定义处理事件，在Pomelo0.5版本中增加了这种服务器生命周期的自定义事件。开发者可以通过application对象的beforeStopHook方法添加自定义事件，示例代码如下：

app.configure('production|development', 'connector', function() {
          var fun = function(app, cb){
            //do something
            cb();
          }
          app.beforeStopHook(fun);
});

pomelo-globalchannel-plugin全局channel插件。
连接加密 在pomelo 0.6版本中，对hybridconnector增加了数据签名的功能。客户端首先产生rsa的密钥对，客户端保留rsa私钥，在握手阶段客户端将公钥发到服务端；在发送消息阶段，客户端使用私钥对消息进行签名，客户端将消息和签名一起发送到服务端，服务端进行签名验证，如果验证成功后面的流程继续，如果验证失败则该数据包则不进行处理。使用方法：

//客户端 
javascript pomelo.init({ host:'127.0.0.1', port:3014, encrypt:true }, function() { // do something connected });
//服务端
app.set('connectorConfig', {
 connector: pomelo.connectors.hybridconnector,
 heartbeat: 3,
 useDict: true,
 useProtobuf: true,
 useCrypto: true
});

在pomelo 0.6版本中增加了更多的rpc日志。开发者只需要在app.js中使用app.enable(‘rpcDebugLog’)即可，另外需要在game-server/config/log4js.json中配置category为rpc-debug的appender，具体配置可以参考如下代码：

{ "type": "file", "filename": "./logs/rpc-debug-${opts:serverId}.log", "maxLogSize": 1048576, "layout": { "type": "basic" }, "backups":5, "category": "rpc-debug" }

##rpc filter提供对外接口根据网友的建议，在新版本中对外提供了添加rpc filter的接口，包括rpcBefore、rpcAfter、rpcFilter，其功能分别为添加before filter, 添加after filter，同时添加两种filter；使用方法与handler的filter类似。上面提供的enableRpcLog选项，可以通过添加rpc filter代替。

app.configure('production|development', function() {
		
	// configurations

	app.filter(pomelo.filters.time());
	app.rpcFilter(pomelo.rpcFilters.rpcLog());
});

过载保护
在pomelo之前的版本中有toobusy模块对服务器进行过载保护，在新版本中增加了一个对connector连接数的限制功能，开发者只需要在servers.json中对不同的connector进行最大连接数量的配置，当connector超过配置的最大数量，服务器会拒绝连接。配置可以参考如下代码：

{"id":"connector-server-1", "host":"127.0.0.1", "port":4050, "clientPort":3050, "frontend":true, "max-connections": 100}

Daemon启动模式pomelo-daemon提供对pomelo服务进行分布式环境下的启动以及rpc调试日志的收集
详细情况请看pomelo-daemon
升级的logger在新版中对pomelo中的logger进行了升级
logger支持自定义前缀输出，把前缀打印在消息的右边，前缀可以是文件名，serverId，host等等
logger在debug模式下支持log行号的打印，方便开发者分析调试
在详细情况下请看pomelo-logger
##定时任务 用户能够通过配置文件或者pomelo-cli的命令addCron和removeCron对定时任务进行动态调度。定时任务是针对具体服务器而言，例如需要在chat服务器中配置定时任务：

首先在game-server/app/servers/chat目录下增加cron目录，在game-server/app/servers/chat/cron目录下编写具体的执行的任务的代码chatCron.js，例如：

module.exports = function(app) {
return new Cron(app);
};
var Cron = function(app) {
this.app = app;
};
var cron = Cron.prototype;

cron.sendMoney = function() {
console.log(’%s server is sending money now!’, this.app.serverId);
};
然后在game-server/config/目录下增加定时任务配置文件crons.json，具体配置文件如下所示：

{
“development”:{
“chat”:[
{“id”:1, “time”: “0 30 10 * * *”, “action”: “chatCron.sendMoney”},
{“id”:2, “serverId”:“chat-server-1”, “time”: “0 30 10 * * *”, “action”: “chatCron.sendMoney”}
]
},
“production”:{
“chat”:[
{“id”:1, “time”: “0 30 10 * * *”, “action”: “chatCron.sendMoney”},
{“id”:2, “serverId”:“chat-server-1”, “time”: “0 30 10 * * *”, “action”: “chatCron.sendMoney”}
]
}
}
在配置文件crons.json中，id是定时任务在具体服务器的唯一标识，且不能在同一服务器中重复；time是定时任务执行的具体时间，时间的定义跟linux的定时任务类似，一共包括7个字段，每个字段的具体定义如下：

*     *     *   *    *        command to be executed

| | | | | |
| | | | | ±---- day of week (0 - 6) (Sunday=0)
| | | | ±------ month (0 - 11)
| | | ±-------- day of month (1 - 31)
| | ±---------- hour (0 - 23)
| ±------------ min (0 - 59)
±------------ second (0 - 59)
0 30 10 * * * 这就代表每天10:30执行相应任务；serverId是一个可选字段，如果有写该字段则该任务只在该服务器下执行，如果没有该字段则该定时任务在所有同类服务器中执行；action是具体执行任务方法，chatCron.sendMoney则代表执行game-server/app/servers/chat/cron/chatCron.js中的sendMoney方法。

通过pomelo-cli的addCron和removeCron命令可以动态地增加和删除定时任务，其中addCron的必要参数包括：id,action,time；removeCron的必要参数包括：id；serverId和serverType是两者选其一即可。例如：

addCron id=8 ‘time=0 30 11 * * *’ action=chatCron.sendMoney serverId=chat-server-3

removeCron id=8

##全局filter

在之前pomelo的版本中，filter是在后端服务器进行消息拦截并进行相应处理；根据网友的意见，在0.7版中在前端服务器增加了filter,请求在前端服务器就可以进行统一处理。请求的处理过程由之前的：前端服务器 -> beforeFilter -> 后端服务器 -> afterFilter 变为：globalBeforeFilter -> 前端服务器 -> beforeFilter -> 后端服务器 -> afterFilter -> globalAfterFilter。同之前的filter的错误处理过程一样，全局filter的错误全部进入globalErrorHandler处理。

全局filter与以前的filter可以相互通用，具体的配置样例如下：

app.configure(‘production|development’, function() {
app.globalFilter(pomelo.serial());
});

在新版中，一个connector可以配置多个pushScheduler，并根据自定义规则selector来进行选择，response以及push新增加的可选参数userOptions可以用于selector的选择计算。下面的示例中就定义了三个不同的pushScheduler，并应用于不同的情况：

app.configure('development', 'connector', function() {

  app.set('pushSchedulerConfig', {

    scheduler: [ 
      {
        id: 'direct',
        scheduler: pomelo.pushSchedulers.direct
      },

      {
        id: 'buffer5',
        scheduler: pomelo.pushSchedulers.buffer,
        options: {flushInterval: 5000}
      },

      {
        id: 'buffer10',
        scheduler: pomelo.pushSchedulers.buffer,
        options: {flushInterval: 10000}
      }
    ],

    selector: function(reqId, route, msg, recvs, opts, cb) {
       // opts.userOptions is passed by response/push/broadcast
       console.log('user options is: ', opts.userOptions);
       if(opts.type === 'push') {
         cb('buffer5');
         return;
       }
       if (opts.type === 'response') {
         cb('direct');
         return ;
       }
       if (opts.type === 'broadcast') {
         cb('buffer10');
         return ;
       }
    }
  });

新的pushScheduler配置与原有的一个connector仅仅支持一个pushScheduler的配置方式保持兼容。

##简化配置文件在0.8版的pomelo中对配置文件servers.json进行了精简，通过增加clusterCount字段将原有的配置进行了简化，这样将更加适合大规模应用的部署和运维管理。

"connector":[
             {"host":"127.0.0.1", "port":"4050++", "clientPort": "3050++", "frontend": true, "clusterCount": 3}
         ],
        "chat":[
             {"host":"127.0.0.1", "port":"6050++", "clusterCount": 3}
        ],
        "gate":[
           {"host": "127.0.0.1", "clientPort": 3014, "frontend": true, "clusterCount": 1}
        ]

同时在采用pomelo-cli进行动态增加服务器的时候，同样可以使用add host=127.0.0.1 port=9000++ serverType=chat clusterCount=3 这样的形式同时增加多台服务器。

##pomelo-logger支持动态日志级别在pomelo-logger0.1.2中，增加了动态改变日志级别的功能，开发者可以在原有的config/log4js.json中配置reloadSecs参数，该参数表示定期检查配置文件是否有更新，如果有更新则重新装载并根据配置文件，更改日志级别。log4js.json配置如下：

{

  ......

  "levels": {

    "pomelo" : "INFO",
    "rpc-log" : "INFO", 
    "forward-log": "ERROR",
    "con-log": "INFO"
  }, 

  "replaceConsole": true,

  "reloadSecs": 60 * 3

}

该配置表示每3分钟检查一次配置文件是否有更新。

RPC调用的IP白名单
该功能可以为各个服务器的RPC调用提供IP白名单过滤功能.

原理
RPC服务端每接受一个连接都会抛出一个连接事件, 这个事件中含有该连接的socket.id和RPC客户端IP. RPC服务端会捕获该连接事件, 并调用用户传入的获取IP白名单的函数, 如果该RPC客户端IP不在白名单中, 则立刻将对应的socket断开. 以此来实现RPC调用白名单过滤功能.

使用
使用时只需要向remoteConfig的配置中传入一个获取IP白名单的函数(whitelist: rpcWhitelist.whitelistFunc)即可, 这个函数需要接受一个回调函数作为其参数, 该回调函数形如function(err, tmpList) {…}. 在获取IP白名单的函数内, 拿到IP白名单时(该白名单应为一维JS Array), 以类似于cb(null, self.gWhitelist)的形式调用IP过滤回调函数.

./game-server/app/util/whitelist.js
... ...
var self = this;
self.gWhitelist = ['192.168.146.100', '192.168.146.101'];
module.exports.whitelistFunc = function(cb) {
  cb(null, self.gWhitelist);
  };
... ...
./game-server/app.js
var rpcWhitelist = require('./app/util/whitelist');
... ...
// configure for global
app.configure('production|development', function() {
... ...
  // remote configures
  app.set('remoteConfig', {
    cacheMsg: true
    , interval: 30
    , whitelist: rpcWhitelist.whitelistFunc
  });
... ...
}

pomelo-admin的IP白名单，原理同上。

./game-server/app/util/whitelist.js
... ...
var self = this;
self.gWhitelist = ['192.168.146.100', '192.168.146.101'];
module.exports.whitelistFunc = function(cb) {
  cb(null, self.gWhitelist);
};
... ...
./game-server/app.js
var adminWhitelist = require('./app/util/whitelist');
... ...
// configure for global
app.configure('production|development', function() {
... ...
  app.set('masterConfig', {
    authUser: app.get('adminAuthUser') // auth client function
    , authServer: app.get('adminAuthServerMaster') // auth server function
    , whitelist: adminWhitelist.whitelistFunc
  });
... ...
}

pomelo rpc支持zeromq通信
在pomelo 0.9中提供了基于zmq的rpc调用，开发者可以根据需要选择原有的pomelo-rpc或者pomelo-rpc-zeromq。基于zeromq和原有的pomelo-rpc的性能对比测试结果可以参考：

具体使用方法：

安装zeromq

在app.js中进行配置，具体配置如下所示：

var zmq = require(‘pomelo-rpc-zeromq’);

app.configure(‘production|development’, function() {

app.set('proxyConfig', {
	rpcClient: zmq.client
});

app.set('remoteConfig', {
	rpcServer: zmq.server
});

});

具体使用示例可以参考 chatofpomelo zmq分支

pomelo-rpc-zeromq性能测试报告与原有的pomelo-rpc的性能测试报告可以参考。

pomelo支持连接黑名单机制
在新版本的pomelo中连接服务器支持静态或者动态添加ip黑名单功能，服务端可以在连接服务器中增加黑名单对攻击的ip进行屏蔽。

原理
connector每接受一个连接都会抛出一个连接事件, 这个事件中含有该连接的客户端IP. connector会捕获该连接事件, 并调用用户传入的获取IP黑名单的函数, 如果该客户端IP在黑名单中, 则立刻将对应的socket断开. 以此来实现连接服务器的黑名单过滤功能.

使用方法
静态添加黑名单
使用时只需要向在connector的connectionConfig配置中传入一个获取IP黑名单的函数即可, 这个函数需要接受一个回调函数作为其参数, 该回调函数形如function(err, list) {…}. 在获取IP黑名单的函数内, 拿到IP黑名单时(该黑名单应为一维JS Array), 以类似于cb(null, self.list)的形式调用IP过滤回调函数，具体使用方法如下：

./game-server/app/util/blackList.js
... ...
var self = this;
self.blackList = ['192.168.100.1', '192.168.100.2'];
module.exports.blackListFun = function(cb) {
  cb(null, self.blackList);
};
... ...
./game-server/app.js
var blackList = require('./app/util/blackList');
... ...
app.configure('production|development', function() {
... ...
  app.set('connectorConfig', {
  	blacklistFun: blackList.blackListFun
  });
... ...
}

动态添加黑名单
动态添加黑名单可以通过pomelo-cli完成，其中运行输入具体ip或者正则表达式，具体命令如下：

blacklist 192.168.100.1
blacklist (([01]?d?d|2[0-4]d|25[0-5]).){3}([01]?d?d|2[0-4]d|25[0-5])

channel 序列化接口
在新版本的pomelo中提供channel的序列化接口，开发者可以通过实现该接口将系统中创建的channel进行保存；同时当服务器重新启动后，系统会将之前保存的channel恢复到系统中。开发者需要实现如下四个接口：

add(key, value, cb)
add key value pairs

remove(key, value, cb)
remove key value pairs

load(key, cb)
load all values

removeAll(key, cb)
remove all values

具体的使用方法如下所示：

var store = require(’./store’);

app.set(‘channelConfig’, {
store : store,
prefix : ‘pomelo’
});

//store.js

var redis = require(‘redis’);

var StoreManager = function() {
this.redis = redis.createClient(6379, ‘127.0.0.1’, {});
};

module.exports = new StoreManager();

StoreManager.prototype.add = function(key, value, cb) {
this.redis.sadd(key, value, function(err) {
cb(err);
});
};

StoreManager.prototype.remove = function(key, value, cb) {
this.redis.srem(key, value, function(err) {
cb(err);
});
};

StoreManager.prototype.load = function(key, cb) {
this.redis.smembers(key, function(err, list) {
cb(err, list);
});
};

StoreManager.prototype.removeAll = function(key, cb) {
this.redis.del(key, function(err) {
cb(err);
});
};

根据网友的要求，在pomelo 1.0中提供了udpconnector。在该udpconnector中，采用了pomelo之前hybridconnector提供的传输协议，包括握手、心跳及数据包的格式。该connector中通过客户端的ip和port来对客户端进行唯一标识，客户端的断开则是通过心跳超时进行判定。

使用方法：

// app configuration

app.configure('production|development', 'connector', function() {

	app.set('connectorConfig',
		{
			connector : pomelo.connectors.udpconnector,
			heartbeat : 3
		});
});

由于pomelo中提供的客户端还没有支持udp的，所以在1.0.0中提供一个node版本的udp client，配合通过pomelo init出来的demo使用，具体可以参考udpclient

pomelo-rpc 负载均衡及容错机制
在pomelo 1.0版本中，pomelo-rpc提供了相关的负载均衡算法，开发者在调用rpc时，可以选择相应的路由算法，rpc框架会根据不同的配置在rpc客户端进行路由算法的选择，从而完成相应的rpc调用。提供的负载均衡算法包括：rr（ROUNDROBIN）, wrr(WEIGHT_ROUNDROBIN), la(LEAST_ACTIVE), ch(CONSISTENT_HASH)。

配置方法：

// rr

app.configure('production|development', 'connector', function() {

	app.set('proxyConfig',
		{
			routerType: 'rr'
		});
});

//基于权重的rr，在servers.json中对rpc目标服务器进行权重配置

app.configure('production|development', 'connector', function() {

	app.set('proxyConfig',
		{
			routerType: 'wrr'
		});
});

 "read": [
 
    {"id": "read-server-1", "host": "127.0.0.1", "port": 4150, "weight": 1},
    {"id": "read-server-2", "host": "127.0.0.1", "port": 4151, "weight": 5},
    {"id": "read-server-3", "host": "127.0.0.1", "port": 4152, "weight": 8}
 ]

//la

app.configure('production|development', 'connector', function() {

	app.set('proxyConfig',
		{
			routerType: 'la'
		});
});

//consistent_hash

app.configure('production|development', 'connector', function() {

	app.set('proxyConfig',
		{
			routerType: 'ch',
            replicas: '100',   //虚拟节点数量
            algorithm: 'md5',  //hash算法
			hashFieldIndex: 0 //根据rpc参数列表中的具体参数进行hash
		});
});

ps:　如果使用toServer(‘chat-server-1’)这种指定rpc目标服务器的rpc调用则不会使用相关的负载均衡算法，如果是指定了routerType则之前在application对象中设置的route函数则无效；综合这三种方式的优先级是toServer > 指定routerType > 指定路由函数。

在新版本中,pomelo-rpc模块提供了相关的容错机制，包括failover，即失败自动切换，当出现失败，重试其它同类型服务器，这种模式通常用于读操作，但重试可能会带来更长延迟；failfast是快速失败，其策略为只发起一次rpc调用，失败后就立即将错误信息返回；failsafe则是一种安全策略，也是rpc默认采用的，即根据rpc的不同类型错误进行不同的处理策略，主要是发起连接重试和发送重试操作。

配置方法：

//快速失败

app.configure('production|development', 'connector', function() {

	app.set('proxyConfig',
		{
			failMode : 'failfast'
		});
});

//切换服务器

app.configure('production|development', 'connector', function() {

	app.set('proxyConfig',
		{
			failMode : 'failover'
		});
});

//安全策略

app.configure('production|development', 'connector', function() {

	app.set('proxyConfig',
		{
			failMode : 'failsafe',
			retryTimes:　3， //重试次数
			retryConnectTime：　5 * 1000 //重连间隔时间
		});
});

ps: rpc默认采用安全策略。

pomelo 支持tls及wss
考虑到安全性方面的问题，pomelo 1.0版本中增加了对tls及wss协议的支持；在之前的pomelo版本中，提供了hybridconnector和sioconnector；对于sioconnector,其底层使用的是socket.io，socket.io提供了包括websocket和长轮询等几种传输方式，其中websocket默认采用的ws协议，现在pomelo支持wss协议，即用户可以在sioconnector中配置基于wss协议的websocket的通信方式；对于hybridconnector,提供包括原生socket的支持和websocket的支持，针对这两种方式，在pomelo 1.0中提供了两种连接的安全版本即tls和wss,用户可以在使用hybridconnector时，采用安全级别较高的tls或者wss。

使用方法：

支持tls客户端，pomelo现在提供的tls客户端有libpomelo.

app.configure('production|development', 'connector', function() {

  app.set('connectorConfig',

    {
      connector : pomelo.connectors.hybridconnector,
      heartbeat : 3,
      useDict : true,
      useProtobuf : true,
      ssl: {
      	key: fs.readFileSync('./keys/server.key'),
  	cert: fs.readFileSync('./keys/server.crt'),
      }
    });
});

支持wss客户端, pomelo提供的wss客户端有js客户端.

app.configure('production|development', 'connector', function() {

  app.set('connectorConfig',

    {
      connector : pomelo.connectors.hybridconnector,
      heartbeat : 3,
      useDict : true,
      useProtobuf : true,
      ssl: {
      	key: fs.readFileSync('./keys/server.key'),
  	cert: fs.readFileSync('./keys/server.crt'),
      }
    });
});

支持socket.io的wss客户端, pomelo提供的socket.io的wss客户端有js客户端.

app.configure('production|development', 'connector', function() {

  app.set('connectorConfig',

    {
      connector : pomelo.connectors.sioconnector,
      key: fs.readFileSync('./keys/server.key'),
  	  cert: fs.readFileSync('./keys/server.crt')
    });
});

在pomelo 1.0中增加了通过pomelo init 获取wss和socket.io的wss两种客户端及服务端的初始化项目，同时初始化的项目中提供了相应的密钥及证书。注意由于证书是和域名绑定的，所以在打开客户端的时候输入的ip地址为 https://127.0.0.1:3001

pomelo 提供自动扩容插件
在pomelo1.0里提供了一个服务器自动扩展的插件，其主要原理是监控某一类型的服务器，监控的指标现在暂时提供cpu和memory，当这一类型的服务器的某项监控指标超过之前设置的阈值时，服务器就自动扩展，扩展服务器的数量可以由用户进行配置。

使用方法：

//app.js配置方法

app.configure('production|development', 'master', function() {

	app.use(scale, {
		scale: {
			cpu: {
				chat: 5,
				interval: 10 * 1000,
				increasement: 1
			},
			memory: {
				connector: 5,
				interval: 15 * 1000,
				increasement: 1
		  },
		  backup: 'config/development/backupServers.json'
		}
	});
});

//backupServer.json配置

{
    "connector":[

             {"id":"backup-connector-server-1", "host":"127.0.0.1", "port":4053, "clientPort": 3053, "frontend": true},
             {"id":"backup-connector-server-2", "host":"127.0.0.1", "port":4054, "clientPort": 3054, "frontend": true},
             {"id":"backup-connector-server-3", "host":"127.0.0.1", "port":4055, "clientPort": 3055, "frontend": true}
         ],
        "chat":[
             {"id":"backup-chat-server-1", "host":"127.0.0.1", "port":6053},
             {"id":"backup-chat-server-2", "host":"127.0.0.1", "port":6054},
             {"id":"backup-chat-server-3", "host":"127.0.0.1", "port":6055}
        ]
}

配置参数说明：

现在监控指标包括cpu和memory两项，在每一个监控指标内可以有监控的服务器类型，例如chat：5，这样就表示chat类型的服务器的阈值为5%，当chat类型的服务器cpu的平均值超过5%后，系统将自动扩展服务器，服务器一次扩展的数量由increasement参数决定，例如increasement参数为1，则表示每次超过阈值后扩展1个服务器，扩展服务器的列表由用户指定，backup参数就是扩展的服务器列表；另外interval参数表示系统检测时间，单位是秒，例如interval: 15 * 1000表示系统每15秒检测一次相应的指标，如果超过该指标则进行相应的扩展。
github地址： pomelo-scale-plugin

超級码力

关注

0
点赞
踩
4

收藏

觉得还不错? 一键收藏
0
评论
pomelo记录一

减少消息数量 — 消息只发送给能看到的玩家。玩家能看到的只是屏幕的大小，而不是整张地图的大小，这样推送消息的时候可以只推给对自己的状态感兴趣的玩家。这个可以用 AOI（area of interested）算法来实现，在 pomelo 的库 pomelo-aoi 中实现了简单的灯塔算法。尽量分进程，进程的粒度越少，出现 tick 超时或 full GC 的可能越少，一定要控制内存大小。在多核时代里，CPU 是最廉价的资源。常规MMO游戏服务器架构：运行架构说明：客户端通过 websocket .
复制链接

扫一扫