@bigtyphoon/melo 1.7.6

package/lib/master/starter.ts

@@ -0,0 +1,234 @@
+import * as cp from 'child_process';
+import { getLogger } from '@bigtyphoon/melo-logger';
+import * as util from 'util';
+import * as utils from '../util/utils';
+import * as Constants from '../util/constants';
+import { ServerInfo } from '../util/constants';
+import * as os from 'os';
+import { melo } from '../melo';
+import { Application } from '../application';
+import * as path from 'path';
+
+let logger = getLogger('melo', path.basename(__filename));
+
+
+let cpus: { [serverId: string]: number } = {};
+let env: string = Constants.RESERVED.ENV_DEV;
+
+/**
+ * Run all servers
+ *
+ * @param {Object} app current application  context
+ * @return {Void}
+ */
+export function runServers(app: Application) {
+    let server, servers;
+    let condition = app.startId || app.type;
+    switch (condition) {
+        case Constants.RESERVED.MASTER:
+            break;
+        case Constants.RESERVED.ALL:
+            servers = app.getServersFromConfig();
+            for (let serverId in servers) {
+                run(app, servers[serverId]);
+            }
+            break;
+        default:
+            server = app.getServerFromConfig(condition);
+            if (!!server) {
+                run(app, server);
+            } else {
+                servers = app.get(Constants.RESERVED.SERVERS)[condition];
+                for (let i = 0; i < servers.length; i++) {
+                    run(app, servers[i]);
+                }
+            }
+    }
+}
+
+/**
+ * Run server
+ *
+ * @param {Object} app current application context
+ * @param {Object} server
+ * @return {Void}
+ */
+export function run(app: Application, server: ServerInfo, cb ?: (err?: string | number) => void) {
+    env = app.get(Constants.RESERVED.ENV);
+    let cmd, key;
+    if (utils.isLocal(server.host)) {
+        let options: string[] = [];
+        if (!!server.args) {
+            if (typeof server.args === 'string') {
+                options.push(server.args.trim());
+            } else {
+                options = options.concat(server.args);
+            }
+        }
+        cmd = app.get(Constants.RESERVED.MAIN);
+        options.push(cmd);
+        options.push(util.format('env=%s', env));
+        for (key in server) {
+            if (key === Constants.RESERVED.CPU) {
+                cpus[server.id] = server[key];
+            }
+            options.push(util.format('%s=%s', key, (server as any)[key]));
+        }
+        localrun(process.execPath, null, options, cb);
+    } else {
+        cmd = util.format('cd "%s" && "%s"', app.getBase(), process.execPath);
+        let arg = server.args;
+        if (arg !== undefined) {
+            if (typeof arg === 'string') {
+                cmd += ' ' + arg.trim()
+            } else {
+                for (let v of arg) {
+                    cmd += ' ' + v.trim()
+                }
+            }
+        }
+        cmd += util.format(' "%s" env=%s ', app.get(Constants.RESERVED.MAIN), env);
+        for (key in server) {
+            if (key === Constants.RESERVED.CPU) {
+                cpus[server.id] = server[key];
+            }
+            cmd += util.format(' %s=%s ', key, (server as any)[key]);
+        }
+        sshrun(cmd, server.host, cb);
+    }
+}
+
+/**
+ * Bind process with cpu
+ *
+ * @param {String} sid server id
+ * @param {String} pid process id
+ * @param {String} host server host
+ * @return {Void}
+ */
+export function bindCpu(app: Application, sid: string, pid: string, host: string) {
+    if (os.platform() === Constants.PLATFORM.LINUX && cpus[sid] !== undefined) {
+        if (utils.isLocal(host)) {
+            let options: string[] = [];
+            options.push('-pc');
+            options.push(String(cpus[sid]));
+            options.push(pid);
+            localrun(Constants.COMMAND.TASKSET, null, options);
+        } else {
+            let cmd = util.format('taskset -pc "%s" "%s"', cpus[sid], pid);
+            sshrun(cmd, host, null);
+        }
+    }
+}
+
+/**
+ * Kill application in all servers
+ *
+ * @param {String} pids  array of server's pid
+ * @param {String} serverIds array of serverId
+ */
+export function kill(app: Application, pids: string[], servers: ServerInfo[]) {
+    let cmd;
+    for (let i = 0; i < servers.length; i++) {
+        let server = servers[i];
+        if (utils.isLocal(server.host)) {
+            let options: string[] = [];
+            if (os.platform() === Constants.PLATFORM.WIN) {
+                cmd = Constants.COMMAND.TASKKILL;
+                options.push('/pid');
+                options.push('/f');
+            } else {
+                cmd = Constants.COMMAND.KILL;
+                options.push(String(-9));
+            }
+            options.push(pids[i]);
+            localrun(cmd, null, options);
+        } else {
+            if (os.platform() === Constants.PLATFORM.WIN) {
+                cmd = util.format('taskkill /pid %s /f', pids[i]);
+            } else {
+                cmd = util.format('kill -9 %s', pids[i]);
+            }
+            sshrun(cmd, server.host);
+        }
+    }
+}
+
+/**
+ * Use ssh to run command.
+ *
+ * @param {String} cmd command that would be executed in the remote server
+ * @param {String} host remote server host
+ * @param {Function} cb callback function
+ *
+ */
+export function sshrun(cmd: string, host: string, cb ?: (err?: string | number) => void) {
+    let args = [];
+    args.push(host);
+    // melo masterha 命令下melo.app为undefined
+    if (melo.app) {
+        let ssh_params = melo.app.get(Constants.RESERVED.SSH_CONFIG_PARAMS);
+        if (!!ssh_params && Array.isArray(ssh_params)) {
+            args = args.concat(ssh_params);
+        }
+    }
+    args.push(cmd);
+
+    logger.info('Executing ' + cmd + ' on ' + host + ':22');
+    spawnProcess(Constants.COMMAND.SSH, host, args, cb);
+    return;
+}
+
+/**
+ * Run local command.
+ *
+ * @param {String} cmd
+ * @param {Callback} callback
+ *
+ */
+export function localrun(cmd: string, host: string, options: string[], callback ?: (err?: string | number) => void) {
+    logger.info('Executing ' + cmd + ' ' + options + ' locally');
+    spawnProcess(cmd, host, options, callback);
+}
+
+/**
+ * Fork child process to run command.
+ *
+ * @param {String} command
+ * @param {Object} options
+ * @param {Callback} callback
+ *
+ */
+let spawnProcess = function (command: string, host: string, options: string[], cb ?: (result: string | number) => void) {
+    let child = null;
+
+    if (env === Constants.RESERVED.ENV_DEV) {
+        child = cp.spawn(command, options);
+        let prefix = command === Constants.COMMAND.SSH ? '[' + host + '] ' : '';
+
+        child.stderr.on('data', function (chunk) {
+            let msg = chunk.toString();
+            process.stderr.write(msg);
+            if (!!cb) {
+                cb(msg);
+            }
+        });
+
+        child.stdout.on('data', function (chunk) {
+            let msg = prefix + chunk.toString();
+            process.stdout.write(msg);
+        });
+    } else {
+        child = cp.spawn(command, options, { detached: true, stdio: 'inherit' });
+        child.unref();
+    }
+
+    child.on('exit', function (code) {
+        if (code !== 0) {
+            logger.warn('child process exit with error, error code: %s, executed command: %s', code, command);
+        }
+        if (typeof cb === 'function') {
+            cb(code === 0 ? null : code);
+        }
+    });
+};

package/lib/master/watchdog.ts

@@ -0,0 +1,135 @@
+import { getLogger } from '@bigtyphoon/melo-logger';
+import * as utils from '../util/utils';
+import * as Constants from '../util/constants';
+import * as countDownLatch from '../util/countDownLatch';
+import { EventEmitter } from 'events';
+import * as util from 'util';
+import { Application } from '../application';
+import { ServerInfo } from '../util/constants';
+import { ConsoleService, MasterAgent } from '@bigtyphoon/melo-admin';
+import * as path from 'path';
+let logger = getLogger('melo', path.basename(__filename));
+
+
+export class Watchdog extends EventEmitter {
+
+    isStarted = false;
+    servers: {[serverId: string]: ServerInfo} = {};
+    _listeners: {[serverId: string]: number} = {};
+    count: number;
+    constructor(private app: Application, private service: ConsoleService) {
+        super();
+
+        this.count = Object.keys(app.getServersFromConfig()).length;
+
+    }
+
+
+    addServer(server: ServerInfo) {
+        if (!server) {
+            return;
+        }
+        this.servers[server.id] = server;
+        this.notify({ action: 'addServer', server: server });
+    }
+
+    removeServer(id: string) {
+        if (!id) {
+            return;
+        }
+        this.unsubscribe(id);
+        delete this.servers[id];
+        this.notify({ action: 'removeServer', id: id });
+    }
+
+    reconnectServer(server: ServerInfo) {
+        let self = this;
+        if (!server) {
+            return;
+        }
+        if (!this.servers[server.id]) {
+            this.servers[server.id] = server;
+        }
+        // replace server in reconnect server
+        this.notifyById(server.id, { action: 'replaceServer', servers: self.servers });
+        // notify other server to add server
+        this.notify({ action: 'addServer', server: server });
+        // add server in listener
+        this.subscribe(server.id);
+    }
+
+    subscribe(id: string) {
+        this._listeners[id] = 1;
+    }
+
+    unsubscribe(id: string) {
+        delete this._listeners[id];
+    }
+
+    query() {
+        return this.servers;
+    }
+
+    record(id: string) {
+        if (!this.isStarted && --this.count < 0) {
+            let usedTime = Date.now() - this.app.startTime;
+            this.notify({ action: 'startOver' });
+            this.isStarted = true;
+            logger.warn('all servers startup in %s ms', usedTime);
+        }
+    }
+
+    notifyById(id: string, msg: any) {
+        (this.service.agent as MasterAgent).request(id, Constants.KEYWORDS.MONITOR_WATCHER, msg, function (signal: any) {
+            if (signal !== Constants.SIGNAL.OK) {
+                logger.error('master watchdog fail to notify to monitor, id: %s, msg: %j', id, msg);
+            } else {
+                logger.debug('master watchdog notify to monitor success, id: %s, msg: %j', id, msg);
+            }
+        });
+    }
+
+    notify(msg: any) {
+        let _listeners = this._listeners;
+        let success = true;
+        let fails: string[] = [];
+        let timeouts: string[] = [];
+        let requests: {[key: string]: number} = {};
+        let count = Object.keys(_listeners).length;
+        if (count === 0) {
+            logger.warn('master watchdog _listeners is none, msg: %j', msg);
+            return;
+        }
+        let latch = countDownLatch.createCountDownLatch(count, { timeout: Constants.TIME.TIME_WAIT_COUNTDOWN }, function (isTimeout) {
+            if (!!isTimeout) {
+                for (let key in requests) {
+                    if (!requests[key]) {
+                        timeouts.push(key);
+                    }
+                }
+                logger.error('master watchdog request timeout message: %j, timeouts: %j, fails: %j', msg, timeouts, fails);
+            }
+            if (!success) {
+                logger.error('master watchdog request fail message: %j, fails: %j', msg, fails);
+            }
+        });
+
+        let moduleRequest = function (self: Watchdog, id: string) {
+            return (function () {
+                (self.service.agent as MasterAgent).request(id, Constants.KEYWORDS.MONITOR_WATCHER, msg, function (signal: any) {
+                    if (signal !== Constants.SIGNAL.OK) {
+                        fails.push(id);
+                        success = false;
+                    }
+                    requests[id] = 1;
+                    latch.done();
+                });
+            })();
+        };
+
+        for (let id in _listeners) {
+            requests[id] = 0;
+            moduleRequest(this, id);
+        }
+    }
+}

package/lib/melo.ts

@@ -0,0 +1,152 @@
+/*!
+ * Melo
+ * Copyright(c) 2012 xiechengchao <xiecc@163.com>
+ * MIT Licensed
+ */
+
+/**
+ * Module dependencies.
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { Application, ApplicationOptions } from './application';
+import { isFunction } from 'util';
+import { BackendSession } from './common/service/backendSessionService';
+import { HybridConnector } from './connectors/hybridconnector';
+import { UDPConnector } from './connectors/udpconnector';
+import { MQTTConnector } from './connectors/mqttconnector';
+import { SIOConnector } from './connectors/sioconnector';
+import { DirectPushScheduler } from './pushSchedulers/direct';
+import { BufferPushScheduler } from './pushSchedulers/buffer';
+import { ChannelService } from './common/service/channelService';
+
+import { ConnectionComponent } from './components/connection';
+import { ConnectorComponent } from './components/connector';
+import { DictionaryComponent } from './components/dictionary';
+import { MasterComponent } from './components/master';
+import { MonitorComponent } from './components/monitor';
+import { ProtobufComponent } from './components/protobuf';
+import { ProxyComponent } from './components/proxy';
+import { PushSchedulerComponent } from './components/pushScheduler';
+import { RemoteComponent } from './components/remote';
+import { ServerComponent } from './components/server';
+import {SessionComponent } from './components/session';
+
+
+import { RpcToobusyFilter } from './filters/rpc/toobusy';
+import { RpcLogFilter } from './filters/rpc/rpcLog';
+import { ToobusyFilter } from './filters/handler/toobusy';
+import { TimeFilter } from './filters/handler/time';
+import { SerialFilter } from './filters/handler/serial';
+import { TimeoutFilter } from './filters/handler/timeout';
+let Package = require('../../package');
+
+import {default as events} from './util/events';
+import { BackendSessionComponent } from './components/backendSession';
+import { ChannelComponent } from './components/channel';
+/**
+ * Expose `createApplication()`.
+ *
+ * @module
+ */
+
+export class Melo {
+    private _app: Application;
+    /**
+     * Framework version.
+     */
+
+    version = Package.version;
+
+    /**
+     * Event definitions that would be emitted by app.event
+     */
+    events = events;
+
+    /**
+     * auto loaded components
+     */
+    components =
+    {
+        backendSession : BackendSessionComponent,
+        channel : ChannelComponent,
+        connection : ConnectionComponent,
+        connector : ConnectorComponent,
+        dictionary : DictionaryComponent,
+        master : MasterComponent,
+        monitor : MonitorComponent,
+        protobuf : ProtobufComponent,
+        proxy : ProxyComponent,
+        pushScheduler : PushSchedulerComponent,
+        remote : RemoteComponent,
+        server : ServerComponent,
+        session : SessionComponent,
+    };
+
+    /**
+     * auto loaded filters
+     */
+    filters =
+    {
+        serial : SerialFilter,
+        time : TimeFilter,
+        timeout : TimeoutFilter,
+        toobusy : ToobusyFilter,
+    };
+
+    /**
+     * auto loaded rpc filters
+     */
+    rpcFilters =
+     {
+        rpcLog : RpcLogFilter,
+        toobusy : RpcToobusyFilter,
+    };
+
+
+    /**
+     * connectors
+     */
+    connectors =
+     {
+        sioconnector : SIOConnector,
+        hybridconnector : HybridConnector,
+        udpconnector : UDPConnector,
+        mqttconnector : MQTTConnector,
+    };
+
+    /**
+     * pushSchedulers
+     */
+    pushSchedulers =
+    {
+        direct : DirectPushScheduler,
+        buffer : BufferPushScheduler,
+    };
+
+    constructor() {
+    }
+
+    /**
+     * Create an melo application.
+     *
+     * @return {Application}
+     * @memberOf Melo
+     * @api public
+     */
+    createApp(opts ?: ApplicationOptions) {
+        let app = new Application();
+        app.init(opts);
+        this._app = app;
+        return app;
+    }
+
+    /**
+     * Get application
+     */
+    get app() {
+        return this._app;
+    }
+}
+
+export let melo = new Melo();