@bigtyphoon/melo 1.7.6

package/lib/components/remote.ts

@@ -0,0 +1,166 @@
+/**
+ * Component for remote service.
+ * Load remote service and add to global context.
+ */
+import * as fs from 'fs';
+import * as pathUtil from '../util/pathUtil';
+import { createServer, Gateway, RpcServerOpts, Remoters, Remoter, RemoteServerCode } from '@bigtyphoon/melo-rpc';
+import { Application } from '../application';
+import { IComponent } from '../interfaces/IComponent';
+import { getLogger, Logger } from '@bigtyphoon/melo-logger';
+import { ServerInfo } from '../util/constants';
+import * as path from 'path';
+
+export interface RemoteComponentOptions extends RpcServerOpts {
+    bufferMsg?: boolean;
+    cacheMsg?: boolean;
+    interval?: number;
+
+    rpcDebugLog?: boolean;
+    rpcLogger?: Logger;
+
+    rpcServer?: { create: (opts?: RemoteComponentOptions) => Gateway };
+
+    /**
+     * convert remote path to relative path (need to upgrade melo-loader to a supported version)
+     * If you want to deploy the project to different paths on multiple servers,
+     * or use the packaging tool to package and deploy on multiple servers, you can enable this function.
+     * each process will have its own running path as the root path
+     */
+    relativePath?: boolean;
+}
+
+/**
+ * Remote component class
+ *
+ * @param {Object} app  current application context
+ * @param {Object} opts construct parameters
+ */
+export class RemoteComponent implements IComponent {
+    opts: RemoteComponentOptions;
+
+    constructor(private app: Application, opts?: RemoteComponentOptions) {
+        opts = opts || {};
+        this.opts = opts;
+
+        // cacheMsg is deprecated, just for compatibility here.
+        opts.bufferMsg = opts.bufferMsg || opts.cacheMsg || false;
+        opts.interval = opts.interval || 30;
+        if (app.enabled('rpcDebugLog')) {
+            opts.rpcDebugLog = true;
+            opts.rpcLogger = getLogger('rpc-debug', path.basename(__filename));
+        }
+
+        opts.relativePath = opts.relativePath || false;
+        opts.paths = this.getRemotePaths(opts.relativePath);
+        opts.context = this.app;
+
+        let remoters: Remoters = {};
+        opts.services = {};
+        opts.services['user'] = remoters;
+
+
+        let info = this.app.getCurrentServer();
+        // 添加插件中的remoter到ServerInfo中
+        for (let plugin of this.app.usedPlugins) {
+            if (plugin.remoterPath) {
+                opts.paths.push({
+                    namespace: 'user',
+                    serverType: info.serverType,
+                    path: plugin.remoterPath
+                });
+            }
+        }
+
+        // 添加路径到ServerInfo中
+        info.remoterPaths = opts.paths;
+
+
+    }
+
+    name = '__remote__';
+    remote: Gateway;
+
+    /**
+     * Remote component lifecycle function
+     *
+     * @param {Function} cb
+     * @return {Void}
+     */
+    start(cb: () => void) {
+        this.opts.port = this.app.getCurServer().port;
+        this.remote = this.genRemote(this.opts);
+        this.remote.start();
+        process.nextTick(cb);
+    }
+
+    /**
+     * Remote component lifecycle function
+     *
+     * @param {Boolean}  force whether stop the component immediately
+     * @param {Function}  cb
+     * @return {Void}
+     */
+    stop(force: boolean, cb: () => void) {
+        this.remote.stop(force);
+        process.nextTick(cb);
+    }
+
+    /**
+     * Get remote paths from application
+     *
+     * @param {Boolean} relativePath convert path to relative path
+     * @return {Array} paths
+     *
+     */
+    getRemotePaths(relativePath?: boolean): RemoteServerCode[] {
+        let paths = [];
+
+        let role;
+        // master server should not come here
+        if (this.app.isFrontend()) {
+            role = 'frontend';
+        } else {
+            role = 'backend';
+        }
+
+        let sysPath = pathUtil.getSysRemotePath(role), serverType = this.app.getServerType();
+        if (sysPath !== null) {
+            paths.push(pathUtil.remotePathRecord('sys', serverType, sysPath, relativePath));
+        }
+        let userPath = pathUtil.getUserRemotePath(this.app.getBase(), serverType);
+        if (userPath !== null) {
+            paths.push(pathUtil.remotePathRecord('user', serverType, userPath, relativePath));
+        }
+
+        return paths;
+    }
+
+    /**
+     * Generate remote server instance
+     *
+     * @param {Object} app current application context
+     * @param {Object} opts contructor parameters for rpc Server
+     * @return {Object} remote server instance
+     */
+    genRemote(opts: RemoteComponentOptions) {
+        if (!!opts.rpcServer) {
+            return opts.rpcServer.create(opts);
+        } else {
+            return createServer(opts);
+        }
+    }
+
+}
+
+export function manualReloadRemoters(app: Application) {
+    if (!app.components.__remote__) {
+        return
+    }
+    const remote = app.components.__remote__.remote;
+    if (remote['manualReloadRemoters']) {
+        remote['manualReloadRemoters']();
+    } else {
+        console.warn('manualReloadRemoters  no method');
+    }
+}

package/lib/components/server.ts

@@ -0,0 +1,71 @@
+/**
+ * Component for server starup.
+ */
+import { Server , create as createServer, ServerOptions, FrontendOrBackendSession } from '../server/server';
+import { IComponent } from '../interfaces/IComponent';
+import { Application } from '../application';
+import { FrontendSession } from '../common/service/sessionService';
+import { HandlerCallback } from '../common/service/handlerService';
+import { BackendSession } from '../common/service/backendSessionService';
+
+/**
+ * Server component class
+ *
+ * @param {Object} app  current application context
+ */
+export class ServerComponent  implements IComponent {
+    server: Server;
+    constructor(app: Application, opts: ServerOptions) {
+        this.server = createServer(app, opts);
+    }
+    name = '__server__';
+
+    /**
+     * Component lifecycle callback
+     *
+     * @param {Function} cb
+     * @return {Void}
+     */
+    start(cb: () => void) {
+        this.server.start();
+        process.nextTick(cb);
+    }
+
+    /**
+     * Component lifecycle callback
+     *
+     * @param {Function} cb
+     * @return {Void}
+     */
+    afterStart(cb: () => void) {
+        this.server.afterStart();
+        process.nextTick(cb);
+    }
+
+
+    /**
+     * Component lifecycle function
+     *
+     * @param {Boolean}  force whether stop the component immediately
+     * @param {Function}  cb
+     * @return {Void}
+     */
+    stop(force: boolean, cb: () => void) {
+        this.server.stop();
+        process.nextTick(cb);
+    }
+
+    /**
+     * Proxy server handle
+     */
+    handle(msg: any, session: FrontendOrBackendSession, cb: HandlerCallback) {
+        this.server.handle(msg, session, cb);
+    }
+
+    /**
+     * Proxy server global handle
+     */
+    globalHandle(msg: any, session: FrontendOrBackendSession, cb: HandlerCallback) {
+        this.server.globalHandle(msg, session, cb);
+    }
+}

package/lib/components/session.ts

@@ -0,0 +1,22 @@
+import { SessionService, SessionServiceOptions } from '../common/service/sessionService';
+import { Application } from '../application';
+import { IComponent } from '../interfaces/IComponent';
+
+
+/**
+ * Session component. Manage sessions.
+ *
+ * @param {Object} app  current application context
+ * @param {Object} opts attach parameters
+ */
+export class SessionComponent extends SessionService implements IComponent {
+    app: Application;
+    constructor(app: Application, opts ?: SessionServiceOptions) {
+        super(opts);
+        this.app = app;
+        app.set('sessionService', this, true);
+    }
+
+    name = '__session__';
+
+}

package/lib/connectors/commands/handshake.ts

@@ -0,0 +1,155 @@
+import { melo } from '../../melo';
+import { Package } from '@bigtyphoon/melo-protocol';
+import { ISocket } from '../../interfaces/ISocket';
+
+let CODE_OK = 200;
+let CODE_USE_ERROR = 500;
+let CODE_OLD_CLIENT = 501;
+
+export type HanshakeFunction = (msg: any , cb: (err ?: Error , resp ?: any) => void , socket: ISocket) => void;
+export type CheckClientFunction = (type: string, version: string) => boolean;
+
+export interface HandshakeCommandOptions {
+    handshake ?: HanshakeFunction;
+    heartbeat ?: number;
+    checkClient ?: CheckClientFunction;
+    useDict ?: boolean;
+    useProtobuf ?: boolean;
+    useCrypto ?: boolean;
+}
+
+/**
+ * Process the handshake request.
+ *
+ * @param {Object} opts option parameters
+ *                      opts.handshake(msg, cb(err, resp)) handshake callback. msg is the handshake message from client.
+ *                      opts.hearbeat heartbeat interval (level?)
+ *                      opts.version required client level
+ */
+export class HandshakeCommand {
+    userHandshake: HanshakeFunction;
+    heartbeatSec: number;
+    heartbeat: number;
+    checkClient: CheckClientFunction;
+    useDict: boolean;
+    useProtobuf: boolean;
+    useCrypto: boolean;
+
+    constructor(opts: HandshakeCommandOptions) {
+        opts = opts || {};
+        this.userHandshake = opts.handshake;
+
+        if (opts.heartbeat) {
+            this.heartbeatSec = opts.heartbeat;
+            this.heartbeat = opts.heartbeat * 1000;
+        }
+
+        this.checkClient = opts.checkClient;
+
+        this.useDict = opts.useDict;
+        this.useProtobuf = opts.useProtobuf;
+        this.useCrypto = opts.useCrypto;
+    }
+
+    handle(socket: ISocket, msg: any) {
+        if (!msg.sys) {
+            processError(socket, CODE_USE_ERROR);
+            return;
+        }
+
+        if (typeof this.checkClient === 'function') {
+            if (!msg || !msg.sys || !this.checkClient(msg.sys.type, msg.sys.version)) {
+                processError(socket, CODE_OLD_CLIENT);
+                return;
+            }
+        }
+
+        let opts: any = {
+            heartbeat: setupHeartbeat(this)
+        };
+
+        if (this.useDict) {
+            let dictVersion = melo.app.components.__dictionary__.getVersion();
+            if (!msg.sys.dictVersion || msg.sys.dictVersion !== dictVersion) {
+
+                // may be deprecated in future
+                opts.dict = melo.app.components.__dictionary__.getDict();
+
+                // 用不到这个。
+            //    opts.routeToCode = melo.app.components.__dictionary__.getDict();
+           //     opts.codeToRoute = melo.app.components.__dictionary__.getAbbrs();
+                opts.dictVersion = dictVersion;
+            }
+            opts.useDict = true;
+        }
+
+        if (this.useProtobuf) {
+            let protoVersion = melo.app.components.__protobuf__.getVersion();
+            if (!msg.sys.protoVersion || msg.sys.protoVersion !== protoVersion) {
+                opts.protos = melo.app.components.__protobuf__.getProtos();
+            }
+            opts.useProto = true;
+        }
+
+        if (!!melo.app.components.__decodeIO__protobuf__) {
+            if (!!this.useProtobuf) {
+                throw new Error('protobuf can not be both used in the same project.');
+            }
+            let component = melo.app.components.__decodeIO__protobuf__ as any;
+            let version = component.getVersion();
+            if (!msg.sys.protoVersion || msg.sys.protoVersion < version) {
+                opts.protos = component.getProtos();
+            }
+            opts.useProto = true;
+        }
+
+        if (this.useCrypto) {
+            melo.app.components.__connector__.setPubKey(socket.id, msg.sys.rsa);
+        }
+
+        if (typeof this.userHandshake === 'function') {
+            this.userHandshake(msg, function (err, resp) {
+                if (err) {
+                    process.nextTick(function () {
+                        processError(socket, CODE_USE_ERROR);
+                    });
+                    return;
+                }
+                process.nextTick(function () {
+                    response(socket, opts, resp);
+                });
+            }, socket);
+            return;
+        }
+
+        process.nextTick(function () {
+            response(socket, opts);
+        });
+    }
+
+}
+
+let setupHeartbeat = function (self: HandshakeCommand) {
+    return self.heartbeatSec;
+};
+
+let response = function (socket: ISocket, sys: any, resp ?: any) {
+    let res: any = {
+        code: CODE_OK,
+        sys: sys
+    };
+    if (resp) {
+        res.user = resp;
+    }
+    socket.handshakeResponse(Package.encode(Package.TYPE_HANDSHAKE, Buffer.from(JSON.stringify(res))));
+};
+
+let processError = function (socket: ISocket, code: number) {
+    let res = {
+        code: code
+    };
+    socket.sendForce(Package.encode(Package.TYPE_HANDSHAKE, Buffer.from(JSON.stringify(res))));
+    process.nextTick(function () {
+        socket.disconnect();
+    });
+};

package/lib/connectors/commands/heartbeat.ts

@@ -0,0 +1,83 @@
+import { Package } from '@bigtyphoon/melo-protocol';
+import { getLogger } from '@bigtyphoon/melo-logger';
+import { ISocket } from '../../interfaces/ISocket';
+import * as path from 'path';
+let logger = getLogger('melo', path.basename(__filename));
+
+
+export interface HeartbeatCommandOptions {
+    disconnectOnTimeout?: boolean;
+    heartbeat?: number;
+    timeout?: number;
+}
+
+/**
+ * Process heartbeat request.
+ *
+ * @param {Object} opts option request
+ *                      opts.heartbeat heartbeat interval
+ */
+export class HeartbeatCommand {
+    heartbeat: number;
+    timeout: number;
+    disconnectOnTimeout: boolean;
+    timeouts: { [socketId: number]: NodeJS.Timeout } = {};
+    clients: { [socketId: number]: number } = {};
+    constructor(opts?: HeartbeatCommandOptions) {
+        opts = opts || {};
+        this.disconnectOnTimeout = opts.disconnectOnTimeout;
+
+        if (opts.heartbeat) {
+            this.heartbeat = opts.heartbeat * 1000; // heartbeat interval
+            this.timeout = opts.timeout * 1000 || this.heartbeat * 2;      // max heartbeat message timeout
+            this.disconnectOnTimeout = true;
+        }
+
+    }
+
+    handle(socket: ISocket) {
+        if (!this.heartbeat) {
+            // no heartbeat setting
+            return;
+        }
+
+        let self = this;
+
+        if (!this.clients[socket.id]) {
+            // clear timers when socket disconnect or error
+            this.clients[socket.id] = 1;
+            socket.once('disconnect', this.clearTimers.bind(this, socket.id));
+            socket.once('error', this.clearTimers.bind(this, socket.id));
+        }
+
+        // clear timeout timer
+        if (self.disconnectOnTimeout) {
+            this.clear(socket.id);
+        }
+
+        socket.sendRaw(Package.encode(Package.TYPE_HEARTBEAT));
+
+        if (self.disconnectOnTimeout) {
+            self.timeouts[socket.id] = setTimeout(function () {
+                logger.info('client %j heartbeat timeout.', socket.id);
+                socket.disconnect();
+            }, self.timeout);
+        }
+    }
+
+    clear(id: number) {
+        let tid = this.timeouts[id];
+        if (tid) {
+            clearTimeout(tid);
+            delete this.timeouts[id];
+        }
+    }
+    clearTimers(id: number) {
+        delete this.clients[id];
+        let tid = this.timeouts[id];
+        if (tid) {
+            clearTimeout(tid);
+            delete this.timeouts[id];
+        }
+    }
+}

package/lib/connectors/commands/kick.ts

@@ -0,0 +1,11 @@
+import { Package } from '@bigtyphoon/melo-protocol';
+import { ISocket } from '../../interfaces/ISocket';
+export function handle(socket: ISocket, reason: string) {
+    // websocket close code 1000 would emit when client close the connection
+    if (typeof reason === 'string') {
+        let res = {
+            reason: reason
+        };
+        socket.sendRaw(Package.encode(Package.TYPE_KICK, Buffer.from(JSON.stringify(res))));
+    }
+}

package/lib/connectors/common/coder.ts

@@ -0,0 +1,93 @@
+import { Message } from '@bigtyphoon/melo-protocol';
+import * as  Constants from '../../util/constants';
+import { getLogger } from '@bigtyphoon/melo-logger';
+import { IConnector } from '../../interfaces/IConnector';
+import * as path from 'path';
+let logger = getLogger('melo', path.basename(__filename));
+
+
+let encode = function (this: IConnector ,  reqId: number, route: string, msg: any) {
+    if (!!reqId) {
+        return composeResponse(this, reqId, route, msg);
+    } else {
+        return composePush(this, route, msg);
+    }
+};
+
+let decode = function (this: any ,  msg: any) {
+    msg = Message.decode(msg.body);
+    let route = msg.route;
+
+    // decode use dictionary
+    if (!!msg.compressRoute) {
+        if (!!this.connector.useDict) {
+            let abbrs = this.dictionary.getAbbrs();
+            if (!abbrs[route]) {
+                logger.error('dictionary error! no abbrs for route : %s', route);
+                return null;
+            }
+            route = msg.route = abbrs[route];
+        } else {
+            logger.error('fail to uncompress route code for msg: %j, server not enable dictionary.', msg);
+            return null;
+        }
+    }
+
+    // decode use protobuf
+    if (!!this.protobuf && !!this.protobuf.getProtos().client[route]) {
+        msg.body = this.protobuf.decode(route, msg.body);
+    } else if (!!this.decodeIO_protobuf && !!this.decodeIO_protobuf.check(Constants.RESERVED.CLIENT, route)) {
+        msg.body = this.decodeIO_protobuf.decode(route, msg.body);
+    } else {
+        try {
+            msg.body = JSON.parse(msg.body.toString('utf8'));
+        } catch (ex) {
+            msg.body = {};
+        }
+    }
+
+    return msg;
+};
+
+let composeResponse = function (server: any, msgId: number, route: string, msgBody: any) {
+    if (!msgId || !route || !msgBody) {
+        return null;
+    }
+    msgBody = encodeBody(server, route, msgBody);
+    return Message.encode(msgId, Message.TYPE_RESPONSE, false, null, msgBody);
+};
+
+let composePush = function (server: any, route: string, msgBody: any) {
+    if (!route || !msgBody) {
+        return null;
+    }
+    msgBody = encodeBody(server, route, msgBody);
+    // encode use dictionary
+    let compressRoute = false;
+    if (!!server.dictionary) {
+        let dict = server.dictionary.getDict();
+        if (!!server.connector.useDict && !!dict[route]) {
+            route = dict[route];
+            compressRoute = true;
+        }
+    }
+    return Message.encode(0, Message.TYPE_PUSH, compressRoute, route, msgBody);
+};
+
+let encodeBody = function (server: any, route: string, msgBody: any) {
+    // encode use protobuf
+    if (!!server.protobuf && !!server.protobuf.getProtos().server[route]) {
+        msgBody = server.protobuf.encode(route, msgBody);
+    } else if (!!server.decodeIO_protobuf && !!server.decodeIO_protobuf.check(Constants.RESERVED.SERVER, route)) {
+        msgBody = server.decodeIO_protobuf.encode(route, msgBody);
+    } else {
+        msgBody = Buffer.from(JSON.stringify(msgBody), 'utf8');
+    }
+    return msgBody;
+};
+
+export
+{
+    encode,
+    decode
+};

package/lib/connectors/common/handler.ts

@@ -0,0 +1,62 @@
+import { Package , Protocol } from '@bigtyphoon/melo-protocol';
+import { getLogger } from '@bigtyphoon/melo-logger';
+import { ISocket } from '../../interfaces/ISocket';
+import * as path from 'path';
+let logger = getLogger('melo', path.basename(__filename));
+
+
+let handlers: {[packageType: number]: (socket: ISocket , pkg: any) => void} = {};
+
+let ST_INITED = 0;
+let ST_WAIT_ACK = 1;
+let ST_WORKING = 2;
+let ST_CLOSED = 3;
+
+let handleHandshake = function (socket: ISocket , pkg: any) {
+    if (socket.state !== ST_INITED) {
+        return;
+    }
+    try {
+        socket.emit('handshake', JSON.parse(Protocol.strdecode(pkg.body)));
+    } catch (ex) {
+        socket.emit('handshake', {});
+    }
+};
+
+let handleHandshakeAck = function (socket: ISocket , pkg: any) {
+    if (socket.state !== ST_WAIT_ACK) {
+        return;
+    }
+    socket.state = ST_WORKING;
+    socket.emit('heartbeat');
+};
+
+let handleHeartbeat = function (socket: ISocket , pkg: any) {
+    if (socket.state !== ST_WORKING) {
+        return;
+    }
+    socket.emit('heartbeat');
+};
+
+let handleData = function (socket: ISocket , pkg: any) {
+    if (socket.state !== ST_WORKING) {
+        return;
+    }
+    socket.emit('message', pkg);
+};
+
+handlers[Package.TYPE_HANDSHAKE] = handleHandshake;
+handlers[Package.TYPE_HANDSHAKE_ACK] = handleHandshakeAck;
+handlers[Package.TYPE_HEARTBEAT] = handleHeartbeat;
+handlers[Package.TYPE_DATA] = handleData;
+
+export default function (socket: ISocket, pkg: any) {
+    let handler = handlers[pkg.type];
+    if (!!handler) {
+        handler(socket, pkg);
+    } else {
+        logger.error('could not find handle invalid data package.');
+        socket.disconnect();
+    }
+}
+

package/lib/connectors/hybrid/IHybridSocket.ts

@@ -0,0 +1,9 @@
+export interface IHybridSocket {
+
+    once(evt: 'close', listener: () => void): void;
+    on(evt: 'error', listener: () => void): void;
+    on(evt: 'message', listener: (msg: any) => void): void;
+    emit(evt: 'close'): void;
+    close(): void;
+    send(msg: any, options?: { binary?: boolean }, listener?: (err?: Error) => void): void;
+}