pomelo记录一

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

运行架构说明：

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

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

7. master服务器的高可用(pomelo-masterha-plugin或者 pomelo-zookeeper-plugin)。master高可用采用多机热备技术，采用主Master+多个备份Master节点的方式实现高可用。当主master宕机时，某一个从master会自动接管主master的工作，并与其他服务器建立连接，继续提供服务，这一过程全部是自动进行的。
8. 在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}
	]
    }
}

9. 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}
	]
     }
}

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

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

11. pomelo-globalchannel-plugin全局channel插件。
12. 连接加密 在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
});

13. 在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());
});

14. 过载保护
    在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}

15. Daemon启动模式pomelo-daemon提供对pomelo服务进行分布式环境下的启动以及rpc调试日志的收集
    详细情况请看pomelo-daemon
16. 升级的logger在新版中对pomelo中的logger进行了升级
    logger支持自定义前缀输出，把前缀打印在消息的右边，前缀可以是文件名，serverId，host等等
    logger在debug模式下支持log行号的打印，方便开发者分析调试
    在详细情况下请看pomelo-logger
17. ##定时任务 用户能够通过配置文件或者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

18. ##全局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());
});

19. 在新版中，一个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的配置方式保持兼容。

20. ##简化配置文件 在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 这样的形式同时增加多台服务器。

21. ##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分钟检查一次配置文件是否有更新。

22. 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
  });
... ...
}

23. 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
  });
... ...
}

24. 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的性能测试报告可以参考。

25. 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])

26. 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);
});
};

27. 根据网友的要求，在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

28. 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默认采用安全策略。

29. 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

30. 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

本文地址：https://blog.csdn.net/u010223072/article/details/107448685