melo-example-robot 1.7.6

package/dist/nodejs-ts-client/my.logger.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MyLogger = void 0;
+const util = require("util");
+const logger_service_1 = require("./logger.service");
+class MyLogger extends logger_service_1.Logger {
+    constructor(context, isTimeDiffEnabled = false) {
+        super(MyLogger.LogPrefix + context, isTimeDiffEnabled);
+    }
+    log(message, ...args) {
+        if (MyLogger.level >= 3 /* MyLogLevel.INFO */) {
+            message = 'LOG<><>' + message;
+            message = util.format(message, ...args);
+            super.log(message);
+        }
+    }
+    info(message, ...args) {
+        if (MyLogger.level >= 3 /* MyLogLevel.INFO */) {
+            message = 'INFO<><>' + message;
+            message = util.format(message, ...args);
+            super.log(message);
+        }
+    }
+    debug(message, ...args) {
+        if (MyLogger.level >= 4 /* MyLogLevel.DEBUG */) {
+            message = 'DEBUG<><>' + message;
+            message = util.format(message, ...args);
+            super.warn(message);
+        }
+    }
+    error(message, ...args) {
+        if (MyLogger.level >= 1 /* MyLogLevel.ERROR */) {
+            message = 'ERROR<><>' + message;
+            message = util.format(message, ...args);
+            super.error(message);
+        }
+    }
+    warn(message, ...args) {
+        if (MyLogger.level >= 2 /* MyLogLevel.WARN */) {
+            message = 'WARN<><>' + message;
+            message = util.format(message, ...args);
+            super.warn(message);
+        }
+    }
+}
+exports.MyLogger = MyLogger;
+MyLogger.LogPrefix = '';
+MyLogger.level = 4 /* MyLogLevel.DEBUG */;
+//# sourceMappingURL=data:application/json;base64,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

package/http.ts

@@ -0,0 +1,64 @@
+import cluster from 'cluster';
+import * as http from 'http';
+let envConfig = require('./app/config/env.json');
+let config = require('./app/config/' + envConfig.env + '/config');
+let path = __filename.substring(0, __filename.lastIndexOf('/'));
+import { Robot } from '@bigtyphoon/melo-robot';
+
+let robot = new Robot(config);
+
+function run(num) {
+    for (let i = 0; i < num; i++) {
+        cluster.fork();
+    }
+}
+
+function stop() {
+    for (let id in cluster.workers) {
+        cluster.workers[id].process.kill();
+    }
+}
+
+function startHttp() {
+    http.createServer(function (req, res) {
+        if (req.method === 'GET') {
+            let url = require('url').parse(req.url, true);
+            if (url.pathname === '/') {
+                return res.end(JSON.stringify(config) + '\n');
+            } else if (url.pathname === '/set') {
+                for (let key in url.query) {
+                    config['apps'][key] = (typeof config[key] === 'number') ? +url.query[key] : url.query[key];
+                }
+                return res.end(JSON.stringify(config) + '\n');
+            } else if (url.pathname === '/restart') {
+                require('child_process').exec('sudo restart client', function () { });
+                return res.end('OK\n');
+            } else if (url.pathname === '/pull') {
+                require('child_process').exec('cd /home/ubuntu/hello && git pull ', function () { });
+                return res.end('OK\n');
+            } else if (url.pathname === '/stop') {
+                setTimeout(function () { stop(); }, 1000);
+                return res.end('HTTP SERVER CLOSE OK\n');
+            } else if (url.pathname === '/start') {
+                let num = url.query['num'] || 1;
+                run(num);
+                return res.end('OK\n' + num);
+            }
+        }
+        res.writeHead(404);
+        res.end('<h1>404<h1>\n');
+    }).listen(config.master.cwebport);
+    console.log(' http server start at http://127.0.0.1:' + config.master.cwebport);
+}
+
+process.on('uncaughtException', function (err) {
+    console.error(' Caught exception: ' + err.stack);
+    require('fs').writeFileSync('/tmp/log', err.stack, 'utf8');
+});
+
+if (cluster.isMaster) {
+    startHttp();
+} else {
+    robot.runAgent(path + envConfig.script);
+}
+

package/nodejs-ts-client/README.md

@@ -0,0 +1,3 @@
+
+nodejs Pomelo client
+

package/nodejs-ts-client/cacheClass.ts

@@ -0,0 +1,21 @@
+
+import * as fs from 'fs';
+
+
+
+class CacheClass {
+    getCache():{dictVersion:string,protoVersion:string,dict:any,protos:any}{
+        try{
+            return JSON.parse(fs.readFileSync(__dirname+'/cache.tmp').toString())as any;
+        }catch (err){
+            return null;
+        }
+    }
+
+    saveCache(cache){
+        fs.writeFileSync(__dirname+'/cache.tmp',JSON.stringify(cache,null,4));
+    }
+}
+
+
+export const cacheClass = new CacheClass();

package/nodejs-ts-client/client.ts

@@ -0,0 +1,475 @@
+import * as WebSocket from 'ws';
+import {Package, Message, Protocol} from '@bigtyphoon/melo-protocol';
+import {Protobuf} from '@bigtyphoon/melo-protobuf';
+import {EventEmitter} from 'events';
+import {cacheClass} from "./cacheClass";
+import { MyLogger } from "./my.logger";
+
+const JS_WS_CLIENT_TYPE = 'js-ws';
+const JS_WS_CLIENT_VERSION = '0.0.1';
+
+const RES_OK = 200;
+const RES_OLD_CLIENT = 501;
+const CODE_DICT_ERROR = 502;
+const CODE_PROTOS_ERROR = 503;
+
+export interface IPomeloInterface {
+    on(event: 'close', cb): any;
+
+    on(event: 'io-error', cb): any;
+
+    on(event: 'error', cb): any;
+
+    on(event: 'heartbeat timeout', cb): any;
+
+    on(event: 'onKick', cb): any;
+
+    initAsync(params): Promise<any>;
+
+    init(params, cb);
+
+    disconnect();
+
+    request(route, msg): Promise<any>;
+
+    notify(route, msg);
+}
+
+export class Pomelo extends EventEmitter implements IPomeloInterface {
+    socket = null;
+    reqId = 0;
+    callbacks = {};
+    handlers = {};
+    routeMap = {};
+    protobuf: Protobuf = null;
+    heartbeatInterval = 5000;
+    heartbeatTimeout = this.heartbeatInterval * 2;
+    nextHeartbeatTimeout = 0;
+    gapThreshold = 100; // heartbeat gap threshold
+    heartbeatId = null;
+    heartbeatTimeoutId = null;
+
+    handshakeCallback = null;
+    logger: MyLogger;
+
+    handshakeBuffer = {
+        'sys': {
+            type: JS_WS_CLIENT_TYPE,
+            version: JS_WS_CLIENT_VERSION,
+            dictVersion: '' as any,
+            protoVersion: '' as any
+        },
+        'user': {}
+    };
+
+    initCallback = null;
+
+    params = null;
+
+
+    data: { dict: any, abbrs: any, protos: any } = {} as any;
+
+    sysCache: { dictVersion: string, protoVersion: string, dict: any, protos: any } = null;
+    static ClientId = 0;
+
+    constructor(useNestLogger = true, private readonly showPackageLog: boolean = true) {
+        super();
+        this.handlers[Package.TYPE_HANDSHAKE] = this.handshake.bind(this);
+        this.handlers[Package.TYPE_HEARTBEAT] = this.heartbeat.bind(this);
+        this.handlers[Package.TYPE_DATA] = this.onData.bind(this);
+        this.handlers[Package.TYPE_KICK] = this.onKick.bind(this);
+        if (useNestLogger) {
+            this.logger = new MyLogger('wsclient-' + ++Pomelo.ClientId);
+        } else {
+            this.logger = console as any;
+        }
+
+    }
+
+    initAsync(params): Promise<any> {
+        return new Promise(resolve => {
+            this.params = params;
+            params.debug = true;
+            this.initCallback = resolve;
+            const host = params.host;
+            const port = params.port;
+
+            let url = host;
+            if (port) {
+                url += ':' + port;
+            }
+            this.sysCache = cacheClass.getCache() || {} as any;
+            this.handshakeBuffer.sys.dictVersion = this.sysCache.dictVersion || 0;
+            this.handshakeBuffer.sys.protoVersion = this.sysCache.protoVersion || 0;
+
+            if (!params.type) {
+                this.logger.log('init websocket');
+                this.handshakeBuffer.user = params.user;
+                this.handshakeCallback = params.handshakeCallback;
+                this.initWebSocket(url, resolve);
+            }
+        })
+    }
+
+    init(params, cb) {
+        this.params = params;
+        params.debug = true;
+        this.initCallback = cb;
+        const host = params.host;
+        const port = params.port;
+
+        let url = 'ws://' + host;
+        if (port) {
+            url += ':' + port;
+        }
+        this.sysCache = cacheClass.getCache() || {} as any;
+        this.handshakeBuffer.sys.dictVersion = this.sysCache.dictVersion || 0;
+        this.handshakeBuffer.sys.protoVersion = this.sysCache.protoVersion || 0;
+
+        if (!params.type) {
+            this.logger.log('init websocket');
+            this.handshakeBuffer.user = params.user;
+            this.handshakeCallback = params.handshakeCallback;
+            this.initWebSocket(url, cb);
+        }
+
+    };
+
+    private initWebSocket(url, cb) {
+        this.logger.log(url);
+        const onopen = (event) => {
+            this.logger.log('[pomeloclient.init] websocket connected!');
+            const obj = Package.encode(Package.TYPE_HANDSHAKE, Protocol.strencode(JSON.stringify(this.handshakeBuffer)));
+            this.send(obj);
+        };
+        const onmessage = (event) => {
+            if (this.showPackageLog && event.data.byteLength != 4) {
+                this.logger.log('recv orgdata', event.data.byteLength, Buffer.from(event.data).toString('hex'));
+            }
+            this.processPackage(Package.decode(event.data));//, cb);
+            // new package arrived, update the heartbeat timeout
+            if (this.heartbeatTimeout) {
+                this.nextHeartbeatTimeout = Date.now() + this.heartbeatTimeout;
+            }
+        };
+        const onerror = (event) => {
+            this.emit('io-error', event);
+            this.logger.log('socket error %j ', event);
+        };
+        const onclose = (event) => {
+            this.emit('close', event);
+            this.logger.log('socket close %j ', event);
+        };
+        this.socket = new WebSocket(url);
+        this.socket.binaryType = 'arraybuffer';
+        this.socket.onopen = onopen;
+        this.socket.onmessage = onmessage;
+        this.socket.onerror = onerror;
+        this.socket.onclose = onclose;
+    };
+
+    disconnect() {
+        if (this.socket) {
+            if (this.socket.disconnect) this.socket.disconnect();
+            if (this.socket.close) this.socket.close();
+            this.logger.log('disconnect');
+            this.socket = null;
+        }
+
+        if (this.heartbeatId) {
+            clearTimeout(this.heartbeatId);
+            this.heartbeatId = null;
+        }
+        if (this.heartbeatTimeoutId) {
+            clearTimeout(this.heartbeatTimeoutId);
+            this.heartbeatTimeoutId = null;
+        }
+    };
+
+    request(route, msg): Promise<any> {
+        return new Promise((resolve, reject) => {
+            msg = msg || {};
+            route = route || msg.route;
+            if (!route) {
+                this.logger.log('fail to send request without route.');
+                return;
+            }
+
+            this.reqId++;
+            this.sendMessage(this.reqId, route, msg);
+
+            this.callbacks[this.reqId] = resolve;
+            this.routeMap[this.reqId] = route;
+        })
+    };
+
+    notify(route, msg) {
+        msg = msg || {};
+        this.sendMessage(0, route, msg);
+    };
+
+    private sendMessage(reqId, route, msg) {
+        const type = reqId ? Message.TYPE_REQUEST : Message.TYPE_NOTIFY;
+        if (this.showPackageLog) {
+            this.logger.log('send', reqId, route, msg);
+        }
+        //compress message by protobuf
+        const protos = !!this.data.protos ? this.data.protos.client : {};
+        if (!!protos[route]) {
+            msg = this.protobuf.encode(route, msg);
+        } else {
+            msg = Protocol.strencode(JSON.stringify(msg));
+        }
+
+        let compressRoute = false;
+        if (this.data.dict && this.data.dict[route]) {
+            route = this.data.dict[route];
+            compressRoute = true;
+        }
+
+        msg = Message.encode(reqId, type, compressRoute, route, msg);
+        const packet = Package.encode(Package.TYPE_DATA, msg);
+        if (this.showPackageLog) {
+            this.logger.log('send', "packet", packet.length, packet.toString('hex'));
+        }
+        this.send(packet);
+    };
+
+    private send(packet) {
+        if (!!this.socket) {
+            this.socket.send(packet.buffer || packet, {binary: true, mask: true});
+        }
+    };
+
+    private heartbeat(data) {
+        const obj = Package.encode(Package.TYPE_HEARTBEAT);
+        if (this.heartbeatTimeoutId) {
+            clearTimeout(this.heartbeatTimeoutId);
+            this.heartbeatTimeoutId = null;
+        }
+
+        if (this.heartbeatId) {
+            // already in a heartbeat interval
+            return;
+        }
+
+        this.heartbeatId = setTimeout(() => {
+            this.heartbeatId = null;
+            this.send(obj);
+
+            this.nextHeartbeatTimeout = Date.now() + this.heartbeatTimeout;
+            this.heartbeatTimeoutId = setTimeout(this.heartbeatTimeoutCb.bind(this), this.heartbeatTimeout);
+        }, this.heartbeatInterval);
+    };
+
+    private heartbeatTimeoutCb() {
+        const gap = this.nextHeartbeatTimeout - Date.now();
+        if (gap > this.gapThreshold) {
+            this.heartbeatTimeoutId = setTimeout(this.heartbeatTimeoutCb.bind(this), gap);
+        } else {
+            this.logger.error('server heartbeat timeout');
+            this.emit('heartbeat timeout');
+            this.disconnect();
+        }
+    };
+
+    private handshake(data) {
+        data = JSON.parse(Protocol.strdecode(data));
+        if (data.code === RES_OLD_CLIENT) {
+            this.emit('error', 'client version not fullfill');
+            return;
+        }
+
+        if (data.code !== RES_OK) {
+            this.emit('error', 'handshake fail');
+            return;
+        }
+
+        this.handshakeInit(data);
+
+        const obj = Package.encode(Package.TYPE_HANDSHAKE_ACK);
+        this.send(obj);
+        if (this.initCallback) {
+            this.initCallback(this.socket);
+            this.initCallback = null;
+        }
+    };
+
+    private onData(data) {
+        //probuff decode
+        const msg = Message.decode(data);
+
+        if (msg.id > 0) {
+            msg.route = this.routeMap[msg.id];
+            delete this.routeMap[msg.id];
+            if (!msg.route) {
+                return;
+            }
+        }
+
+        msg.body = this.deCompose(msg);
+        if (this.showPackageLog) {
+            this.logger.log('recv', JSON.stringify(msg), "\n\tpacket", data.length, data.toString('hex'));
+        }
+        this.processMessage(msg);
+    };
+
+
+    private onKick(data) {
+        this.emit('onKick', data.toString());
+    };
+
+    private processPackage(msg) {
+        if (Array.isArray(msg)) {
+            for (let m of msg) {
+                this.handlers[m.type](m.body);
+            }
+        } else {
+            this.handlers[msg.type](msg.body);
+        }
+
+    };
+
+    private processMessage(msg) {
+        if (!msg || !msg.id) {
+            // server push message
+            // this.logger.error('processMessage error!!!');
+            this.emit(msg.route, msg.body);
+            return;
+        }
+
+        //if have a id then find the callback function with the request
+        const cb = this.callbacks[msg.id];
+
+        delete this.callbacks[msg.id];
+        if (typeof cb !== 'function') {
+            return;
+        }
+
+        cb(msg.body);
+        return;
+    };
+
+    private processMessageBatch(pomelo, msgs) {
+        for (let i = 0, l = msgs.length; i < l; i++) {
+            this.processMessage(msgs[i]);
+        }
+    };
+
+    private deCompose(msg) {
+        const protos = !!this.data.protos ? this.data.protos.server : {};
+        const abbrs = this.data.abbrs;
+        let route = msg.route;
+
+        try {
+            //Decompose route from dict
+            if (msg.compressRoute) {
+                if (!abbrs[route]) {
+                    this.logger.error('illegal msg!');
+                    return {};
+                }
+
+                route = msg.route = abbrs[route];
+            }
+            if (!!protos[route]) {
+                return this.protobuf.decode(route, msg.body);
+            } else {
+                return JSON.parse(Protocol.strdecode(msg.body));
+            }
+        } catch (ex) {
+            this.logger.error('route, body = ' + route + ", " + msg.body);
+        }
+
+        return msg;
+    };
+
+    private handshakeInit(data) {
+        if (data.sys && data.sys.heartbeat) {
+            this.heartbeatInterval = data.sys.heartbeat * 1000;   // heartbeat interval
+            this.heartbeatTimeout = this.heartbeatInterval * 2;        // max heartbeat timeout
+        } else {
+            this.heartbeatInterval = 0;
+            this.heartbeatTimeout = 0;
+        }
+
+        this.initData(data);
+
+        if (typeof this.handshakeCallback === 'function') {
+            this.handshakeCallback(data.user);
+        }
+    };
+
+    //Initilize data used in pomelo client
+    private initData(data) {
+        if (!data || !data.sys) {
+            return;
+        }
+
+        const dictVersion = data.sys.dictVersion;
+        const protoVersion = data.sys.protos ? data.sys.protos.version : null;
+
+        let changed = false;
+        const dict = data.sys.dict || this.sysCache.dict;
+        const protos = data.sys.protos || this.sysCache.protos;
+
+        if (dictVersion) {
+            this.sysCache.dict = dict;
+            this.sysCache.dictVersion = dictVersion;
+            changed = true;
+        }
+
+        if (protoVersion) {
+            this.sysCache.protos = protos;
+            this.sysCache.protoVersion = protoVersion;
+            changed = true;
+        }
+        if (changed) {
+            cacheClass.saveCache(this.sysCache);
+        }
+        //Init compress dict
+        if (!!dict) {
+            this.data.dict = dict;
+            this.data.abbrs = {};
+
+            for (const route in dict) {
+                this.data.abbrs[dict[route]] = route;
+            }
+        }
+
+        //Init protobuf protos
+        if (!!protos) {
+            this.data.protos = {
+                server: protos.server || {},
+                client: protos.client || {}
+            };
+            if (!this.protobuf) {
+                // 要改WEB JS客户端的话 这里可能需要改一下。
+                this.protobuf = new Protobuf({encoderProtos: protos.client, decoderProtos: protos.server});
+            }
+        }
+    };
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+