@bigtyphoon/melo 1.7.6

package/lib/common/manager/appManager.ts

@@ -0,0 +1,118 @@
+import * as async from 'async';
+import * as utils from '../../util/utils';
+import { getLogger } from '@bigtyphoon/melo-logger';
+let logger = getLogger('melo', __filename);
+let transactionLogger = getLogger('transaction-log', __filename);
+let transactionErrorLogger = getLogger('transaction-error-log', __filename);
+
+export type TransactionCondictionFunction = (cb: (err ?: Error) => void) => void;
+export type TransactionHandlerFunction = (cb: (err ?: Error) => void) => void;
+
+export function transaction(name: string, conditions: { [key: string]: TransactionCondictionFunction }, handlers: { [key: string]: TransactionHandlerFunction }, retry?: number) {
+    if (!retry) {
+        retry = 1;
+    }
+    if (typeof name !== 'string') {
+        logger.error('transaction name is error format, name: %s.', name);
+        return;
+    }
+    if (typeof conditions !== 'object' || typeof handlers !== 'object') {
+        logger.error('transaction conditions parameter is error format, conditions: %j, handlers: %j.', conditions, handlers);
+        return;
+    }
+
+    let cmethods: TransactionCondictionFunction[] = [];
+    let dmethods: TransactionHandlerFunction[] = [];
+    let cnames: string[] = [];
+    let dnames: string[] = [];
+    for (let key in conditions) {
+        if (typeof key !== 'string' || typeof conditions[key] !== 'function') {
+            logger.error('transaction conditions parameter is error format, condition name: %s, condition function: %j.', key, conditions[key]);
+            return;
+        }
+        cnames.push(key);
+        cmethods.push(conditions[key]);
+    }
+
+    let i = 0;
+    // execute conditions
+    async.forEachSeries(cmethods, function (method, cb) {
+        method(cb);
+        transactionLogger.info('[%s]:[%s] condition is executed.', name, cnames[i]);
+        i++;
+    }, function (err: Error) {
+        if (err) {
+            process.nextTick(function () {
+                transactionLogger.error('[%s]:[%s] condition is executed with err: %j.', name, cnames[--i], err.stack);
+                let log = {
+                    name: name,
+                    method: cnames[i],
+                    time: Date.now(),
+                    type: 'condition',
+                    description: err.stack
+                };
+                transactionErrorLogger.error(JSON.stringify(log));
+            });
+            return;
+        } else {
+            // execute handlers
+            process.nextTick(function () {
+                for (let key in handlers) {
+                    if (typeof key !== 'string' || typeof handlers[key] !== 'function') {
+                        logger.error('transcation handlers parameter is error format, handler name: %s, handler function: %j.', key, handlers[key]);
+                        return;
+                    }
+                    dnames.push(key);
+                    dmethods.push(handlers[key]);
+                }
+
+                let flag = true;
+                let times = retry;
+
+                // do retry if failed util retry times
+                async.whilst(
+                    function () {
+                        return retry > 0 && flag;
+                    },
+                    function (callback) {
+                        let j = 0;
+                        retry--;
+                        async.forEachSeries(dmethods, function (method, cb) {
+                            method(cb);
+                            transactionLogger.info('[%s]:[%s] handler is executed.', name, dnames[j]);
+                            j++;
+                        }, function (err: Error) {
+                            if (err) {
+                                process.nextTick(function () {
+                                    transactionLogger.error('[%s]:[%s]:[%s] handler is executed with err: %j.', name, dnames[--j], times - retry, err.stack);
+                                    let log = {
+                                        name: name,
+                                        method: dnames[j],
+                                        retry: times - retry,
+                                        time: Date.now(),
+                                        type: 'handler',
+                                        description: err.stack
+                                    };
+                                    transactionErrorLogger.error(JSON.stringify(log));
+                                    utils.invokeCallback(callback);
+                                });
+                                return;
+                            }
+                            flag = false;
+                            utils.invokeCallback(callback);
+                            process.nextTick(function () {
+                                transactionLogger.info('[%s] all conditions and handlers are executed successfully.', name);
+                            });
+                        });
+                    },
+                    function (err) {
+                        if (err) {
+                            logger.error('transaction process is executed with error: %j', err);
+                        }
+                        // callback will not pass error
+                    }
+                );
+            });
+        }
+    });
+}

package/lib/common/manager/taskManager.ts

@@ -0,0 +1,50 @@
+let sequeue = require('seq-queue');
+
+export interface QueueTask {
+
+}
+
+export interface Queue {
+    push(fn: (task: QueueTask) => void, ontimeout: () => void, timeoutMs: number): void;
+
+    close(force: boolean): void;
+}
+
+
+let queues: { [key: number]: Queue } = {};
+
+export let timeout = 3000;
+
+/**
+ * Add tasks into task group. Create the task group if it dose not exist.
+ *
+ * @param {String}   key       task key
+ * @param {Function} fn        task callback
+ * @param {Function} ontimeout task timeout callback
+ * @param {Number}   timeout   timeout for task
+ */
+export function addTask(key: number, fn: (task: QueueTask) => void, ontimeout: () => void, timeoutMs: number) {
+    let queue = queues[key];
+    if (!queue) {
+        queue = sequeue.createQueue(timeout);
+        queues[key] = queue;
+    }
+
+    return queue.push(fn, ontimeout, timeoutMs);
+}
+
+/**
+ * Destroy task group
+ *
+ * @param  {String} key   task key
+ * @param  {Boolean} force whether close task group directly
+ */
+export function closeQueue(key: number, force: boolean) {
+    if (!queues[key]) {
+        // ignore illeagle key
+        return;
+    }
+
+    queues[key].close(force);
+    queues[key] = undefined;
+}

package/lib/common/remote/backend/msgRemote.ts

@@ -0,0 +1,134 @@
+import * as utils from '../../../util/utils';
+import { getLogger } from '@bigtyphoon/melo-logger';
+import { Application } from '../../../application';
+import { BackendSession } from '../../service/backendSessionService';
+import * as path from 'path';
+import { ISession } from '../../service/sessionService';
+
+let logger = getLogger('forward-log', path.basename(__filename));
+/**
+ * Remote service for backend servers.
+ * Receive and handle request message forwarded from frontend server.
+ */
+export default function (app: Application) {
+    return new MsgRemote(app);
+}
+
+export class MsgRemote {
+    app: Application;
+
+    constructor(app: Application) {
+        this.app = app;
+    }
+
+    /**
+     * Forward message from frontend server to other server's handlers
+     *
+     * @param msg {Object} request message
+     * @param session {Object} session object for current request
+     * @param cb {Function} callback function
+     */
+    forwardMessage(msg: any, session: ISession) {
+        return new Promise<any>((resolve, reject) => {
+            let server = this.app.components.__server__;
+            let sessionService = this.app.components.__backendSession__;
+
+            if (!server) {
+                logger.error('server component not enable on %s', this.app.serverId);
+                reject(new Error('server component not enable'));
+                return;
+            }
+
+            if (!sessionService) {
+                logger.error('backend session component not enable on %s', this.app.serverId);
+                reject(new Error('backend sesssion component not enable'));
+                return;
+            }
+
+            // generate backend session for current request
+            let backendSession = sessionService.create(session);
+
+            // handle the request
+
+            logger.debug('session:[%s,%s,%s], handle message: %j', session.id, session.uid, session.frontendId, msg);
+
+            server.handle(msg, backendSession, function (err, resp) {
+                logger.debug('session:[%s,%s,%s], handle message result,err:%j,msg:%j,resp:%j', session.id, session.uid, session.frontendId, err, msg, resp);
+                // 如果有给response 那就不给connector错误。给response.
+                // 因为promise，所以与pomelo有点不一致，pomelo把err与resp一起传回connector了
+                if (err) {
+                    if (resp) {
+                        logger.error('session:[%s,%s,%s], handle message %j, error:%j', session.id, session.uid, session.frontendId, msg, err);
+                        return resolve(resp);
+                    }
+                    reject(err);
+                }
+                else {
+                    resolve(resp);
+                }
+            });
+        });
+    }
+
+    /*
+    forwardMessage2(route : string , body : any, aesPassword : string, compressGzip : boolean, session :BackendSession)
+    {
+        return new Promise<any>((resolve, reject) =>
+        {
+            let server = this.app.components.__server__;
+            let sessionService = this.app.components.__backendSession__;
+
+            if (!server)
+            {
+                logger.error('server component not enable on %s', this.app.serverId);
+                reject(new Error('server component not enable'));
+                return;
+            }
+
+            if (!sessionService)
+            {
+                logger.error('backend session component not enable on %s', this.app.serverId);
+                reject(new Error('backend sesssion component not enable'));
+                return;
+            }
+
+            // generate backend session for current request
+            let backendSession = sessionService.create(session);
+
+            // handle the request
+
+            // logger.debug('backend server [%s] handle message: %j', this.app.serverId, msg);
+
+            let dmsg = {
+                route: route,
+                body: body,
+                compressGzip: compressGzip
+            }
+
+            let socket = {
+                aesPassword: aesPassword
+            }
+
+            let connector = this.app.components.__connector__.connector;
+            connector.runDecode(dmsg, socket, function (err : Error, msg : any)
+            {
+                if (err)
+                {
+                    return reject(err);
+                }
+
+                server.handle(msg, backendSession, function (err : Error, resp : any)
+                {
+                    if (err)
+                    {
+                        reject(err);
+                    }
+                    else
+                    {
+                        resolve(resp);
+                    }
+                });
+            });
+        });
+    }*/
+}

package/lib/common/remote/frontend/channelRemote.ts

@@ -0,0 +1,91 @@
+/**
+ * Remote channel service for frontend server.
+ * Receive push request from backend servers and push it to clients.
+ */
+import * as utils from '../../../util/utils';
+import {getLogger} from '@bigtyphoon/melo-logger';
+import {Application} from '../../../application';
+import {UID, SID} from '../../../util/constants';
+import {ScheduleOptions} from '../../../interfaces/IPushScheduler';
+import {Session} from '../../service/sessionService';
+import * as path from 'path';
+
+let logger = getLogger('melo', path.basename(__filename));
+
+export default function (app: Application) {
+    return new ChannelRemote(app);
+}
+
+export class ChannelRemote {
+    app: Application;
+
+    constructor(app: Application) {
+        this.app = app;
+    }
+
+    /**
+     * Push message to client by uids.
+     *
+     * @param  {String}   route route string of message
+     * @param  {Object}   msg   message
+     * @param  {Array}    uids  user ids that would receive the message
+     * @param  {Object}   opts  push options
+     * @param  {Function} cb    callback function
+     */
+    pushMessage(route: string, msg: any, uids: UID[], opts: ScheduleOptions) {
+        return new Promise<any>((resolve, reject) => {
+            if (!msg) {
+                logger.error('Can not send empty message! route : %j, compressed msg : %j',
+                    route, msg);
+                return reject(new Error('can not send empty message.'));
+            }
+
+            let connector = this.app.components.__connector__;
+
+            let sessionService = this.app.get('sessionService');
+            let fails: UID[] = [], sids: SID[] = [], sessions: Session[], j: number, k: number;
+            for (let i = 0, l = uids.length; i < l; i++) {
+                sessions = sessionService.getByUid(uids[i]);
+                if (!sessions) {
+                    fails.push(uids[i]);
+                } else {
+                    for (j = 0, k = sessions.length; j < k; j++) {
+                        sids.push(sessions[j].id);
+                    }
+                }
+            }
+            logger.debug('[%s] pushMessage uids: %j, msg: %j, sids: %j', this.app.serverId, uids, msg, sids);
+            connector.send(null, route, msg, sids, opts, function (err) {
+                if (err) {
+                    return reject(err);
+                }
+                else {
+                    return resolve(fails);
+                }
+            });
+        });
+    }
+
+    /**
+     * Broadcast to all the client connectd with current frontend server.
+     *
+     * @param  {String}    route  route string
+     * @param  {Object}    msg    message
+     * @param  {Boolean}   opts   broadcast options.
+     * @param  {Function}  cb     callback function
+     */
+    broadcast(route: string, msg: any, opts: ScheduleOptions) {
+        return new Promise<any>((resolve, reject) => {
+            let connector = this.app.components.__connector__;
+
+            connector.send(null, route, msg, null, opts, function (err, resp) {
+                if (err) {
+                    return reject(err);
+                }
+                else {
+                    return resolve(resp);
+                }
+            });
+        });
+    }
+}

package/lib/common/remote/frontend/sessionRemote.ts

@@ -0,0 +1,91 @@
+/**
+ * Remote session service for frontend server.
+ * Set session info for backend servers.
+ */
+import * as utils from '../../../util/utils';
+import {Application} from '../../../application';
+import {SID, UID} from '../../../util/constants';
+
+export default function (app: Application) {
+    return new SessionRemote(app);
+}
+
+
+export class SessionRemote {
+    app: Application;
+
+    constructor(app: Application) {
+        this.app = app;
+    }
+
+    bind(sid: SID, uid: UID) {
+        return this.app.sessionService.abind(sid, uid);
+    }
+
+    unbind(sid: SID, uid: UID) {
+        return this.app.sessionService.aunbind(sid, uid);
+    }
+
+    push(sid: SID, key: string, value: any) {
+        return this.app.sessionService.aimport(sid, key, value);
+    }
+
+    pushAll(sid: SID, settings: { [key: string]: any }) {
+        return this.app.sessionService.aimportAll(sid, settings);
+    }
+
+    /**
+     * Get session informations with session id.
+     *
+     * @param  {String}   sid session id binded with the session
+     * @param  {Function} cb(err, sinfo)  callback funtion, sinfo would be null if the session not exist.
+     */
+    getBackendSessionBySid(sid: SID) {
+        let session = this.app.sessionService.get(sid);
+        if (!session) {
+            return;
+        }
+        return session.toFrontendSession().export();
+    }
+
+    /**
+     * Get all the session informations with the specified user id.
+     *
+     * @param  {String}   uid user id binded with the session
+     * @param  {Function} cb(err, sinfo)  callback funtion, sinfo would be null if the session does not exist.
+     */
+    getBackendSessionsByUid(uid: UID) {
+        let sessions = this.app.sessionService.getByUid(uid);
+        if (!sessions) {
+            return;
+        }
+
+        let res = [];
+        for (let i = 0, l = sessions.length; i < l; i++) {
+            res.push(sessions[i].toFrontendSession().export());
+        }
+        return res;
+    }
+
+    /**
+     * Kick a session by session id.
+     *
+     * @param  {Number}   sid session id
+     * @param  {String}   reason  kick reason
+     * @param  {Function} cb  callback function
+     */
+    kickBySid(sid: SID, reason: string) {
+        return this.app.sessionService.akickBySessionId(sid, reason);
+    }
+
+    /**
+     * Kick sessions by user id.
+     *
+     * @param  {Number|String}   uid user id
+     * @param  {String}          reason     kick reason
+     * @param  {Function} cb     callback function
+     */
+    kickByUid(uid: UID, reason: string) {
+        return this.app.sessionService.akick(uid, reason);
+    }
+}