@bigtyphoon/melo 1.7.6

package/lib/connectors/hybrid/switcher.ts

@@ -0,0 +1,142 @@
+import { EventEmitter } from 'events';
+import * as util from 'util';
+import { WSProcessor } from './wsprocessor';
+import { TCPProcessor } from './tcpprocessor';
+import { getLogger } from '@bigtyphoon/melo-logger';
+import * as net from 'net';
+import * as tls from 'tls';
+import { TlsOptions } from 'tls';
+import * as WebSocket from 'ws';
+import { TcpSocket } from './tcpsocket';
+import { IHybridSocket } from './IHybridSocket';
+import * as path from 'path';
+let logger = getLogger('melo', path.basename(__filename));
+
+
+let HTTP_METHODS = [
+    'GET', 'POST', 'DELETE', 'PUT', 'HEAD'
+];
+// max length of 'DELETE'
+let MAX_HTTP_METHODS_LEN = 6;
+
+let ST_STARTED = 1;
+let ST_CLOSED = 2;
+
+let DEFAULT_TIMEOUT = 90;
+
+export type SslWatcher = (cb: (opts: tls.SecureContextOptions) => void) => void;
+export interface HybridSwitcherOptions {
+    closeMethod ?: 'end';
+    timeout ?: number;
+    setNoDelay ?: boolean;
+    ssl ?: TlsOptions;
+    sslWatcher?: SslWatcher;
+}
+export interface IHybridSwitcher {
+    on(evt: 'connection' , listener: (socket: IHybridSocket) => void): void;
+}
+
+/**
+ * Switcher for tcp and websocket protocol
+ *
+ * @param {Object} server tcp server instance from node.js net module
+ */
+export class HybridSwitcher extends EventEmitter implements IHybridSwitcher {
+    server: net.Server;
+    wsprocessor: WSProcessor;
+    tcpprocessor: TCPProcessor;
+    id: number;
+    timeout: number;
+    setNoDelay: boolean;
+    state: number;
+
+
+    constructor(server: net.Server, opts: HybridSwitcherOptions) {
+        super();
+        this.server = server;
+        this.wsprocessor = new WSProcessor();
+        this.tcpprocessor = new TCPProcessor(opts.closeMethod);
+        this.id = 1;
+        this.timeout = (opts.timeout || DEFAULT_TIMEOUT) * 1000;
+        this.setNoDelay = opts.setNoDelay;
+
+        if (!opts.ssl) {
+            this.server.on('connection', this.newSocket.bind(this));
+        } else {
+            this.server.on('secureConnection', this.newSocket.bind(this));
+            this.server.on('clientError', function (e, tlsSo) {
+                logger.warn('an ssl error occured before handshake established: ', e);
+                tlsSo.destroy();
+            });
+        }
+
+        this.wsprocessor.on('connection', this.emit.bind(this, 'connection'));
+        this.tcpprocessor.on('connection', this.emit.bind(this, 'connection'));
+
+        this.state = ST_STARTED;
+    }
+
+    newSocket(socket: net.Socket) {
+        if (this.state !== ST_STARTED) {
+            return;
+        }
+
+        socket.on('error',  (err: Error) => {
+            logger.debug('connection error:%s, the remote ip is %s && port is %s', err.message, socket.remoteAddress, socket.remotePort);
+            socket.destroy();
+        });
+
+        socket.on('close',  () => {
+            socket.destroy();
+        });
+        socket.setTimeout(this.timeout, function () {
+            logger.warn('connection is timeout without communication, the remote ip is %s && port is %s',
+                socket.remoteAddress, socket.remotePort);
+            socket.destroy();
+        });
+
+        let self = this;
+
+        socket.once('data',  (data) => {
+            // FIXME: handle incomplete HTTP method
+            if (isHttp(data)) {
+                this.processHttp(self.wsprocessor, socket, data);
+            } else {
+                if (!!self.setNoDelay) {
+                    socket.setNoDelay(true);
+                }
+                this.processTcp(self.tcpprocessor, socket, data);
+            }
+        });
+    }
+
+    close() {
+        if (this.state !== ST_STARTED) {
+            return;
+        }
+
+        this.state = ST_CLOSED;
+        this.wsprocessor.close();
+        this.tcpprocessor.close();
+    }
+
+    private processHttp(processor: WSProcessor, socket: net.Socket, data: Buffer) {
+        processor.add(socket, data);
+    }
+
+    private processTcp(processor: TCPProcessor, socket: net.Socket, data: Buffer) {
+        processor.add(socket, data);
+    }
+
+}
+let isHttp = function (data: Buffer) {
+    let head = data.toString('utf8', 0, MAX_HTTP_METHODS_LEN - 1);
+
+    for (let i = 0, l = HTTP_METHODS.length; i < l; i++) {
+        if (head.indexOf(HTTP_METHODS[i]) === 0) {
+            return true;
+        }
+    }
+
+    return false;
+};

package/lib/connectors/hybrid/tcpprocessor.ts

@@ -0,0 +1,43 @@
+import { EventEmitter } from 'events';
+import * as util from 'util';
+import * as net from 'net';
+import * as utils from '../../util/utils';
+import { TcpSocket } from './tcpsocket';
+
+let ST_STARTED = 1;
+let ST_CLOSED = 2;
+
+// private protocol, no need exports
+let HEAD_SIZE = 4;
+
+/**
+ * websocket protocol processor
+ */
+export class TCPProcessor extends EventEmitter {
+    closeMethod: 'end';
+    state: number;
+    constructor(closeMethod?: 'end') {
+        super();
+        this.closeMethod = closeMethod;
+        this.state = ST_STARTED;
+    }
+    add(socket: net.Socket, data: Buffer) {
+        if (this.state !== ST_STARTED) {
+            return;
+        }
+        let tcpsocket = new TcpSocket(socket, {
+            headSize: HEAD_SIZE,
+            headHandler: utils.headHandler,
+            closeMethod: this.closeMethod
+        });
+        this.emit('connection', tcpsocket);
+        socket.emit('data', data);
+    }
+
+    close() {
+        if (this.state !== ST_STARTED) {
+            return;
+        }
+        this.state = ST_CLOSED;
+    }
+}

package/lib/connectors/hybrid/tcpsocket.ts

@@ -0,0 +1,223 @@
+import {Stream} from 'stream';
+import * as util from 'util';
+import * as net from 'net';
+import {Package} from '@bigtyphoon/melo-protocol';
+import {getLogger} from '@bigtyphoon/melo-logger';
+import {ISocket} from '../../interfaces/ISocket';
+import {IHybridSocket} from './IHybridSocket';
+import * as path from 'path';
+
+let logger = getLogger('melo', path.basename(__filename));
+
+
+export interface TcpSocketOptions {
+    headSize: number;
+    headHandler: (data: Buffer) => number;
+    closeMethod?: 'end';
+}
+
+/**
+ * Work states
+ */
+let ST_HEAD = 1;      // wait for head
+let ST_BODY = 2;      // wait for body
+let ST_CLOSED = 3;    // closed
+
+/**
+ * Tcp socket wrapper with package compositing.
+ * Collect the package from socket and emit a completed package with 'data' event.
+ * Uniform with ws.WebSocket interfaces.
+ *
+ * @param {Object} socket origin socket from node.js net module
+ * @param {Object} opts   options parameter.
+ *                        opts.headSize size of package head
+ *                        opts.headHandler(headBuffer) handler for package head. caculate and return body size from head data.
+ */
+export class TcpSocket extends Stream implements IHybridSocket {
+    readable: boolean;
+    writeable: boolean;
+
+    _socket: net.Socket;
+    headSize: number;
+    closeMethod: string;
+    headBuffer: Buffer;
+    headHandler: Function;
+
+    headOffset: number;
+    packageOffset: number;
+    packageSize: number;
+    packageBuffer: Buffer;
+    state: number;
+
+    constructor(socket: net.Socket, opts?: TcpSocketOptions) {
+        // stream style interfaces.
+        // TODO: need to port to stream2 after node 0.9
+        super();
+        if (!socket || !opts) {
+            throw new Error('invalid socket or opts');
+        }
+
+        if (!opts.headSize || typeof opts.headHandler !== 'function') {
+            throw new Error('invalid opts.headSize or opts.headHandler');
+        }
+
+        this.readable = true;
+        this.writeable = true;
+
+        this._socket = socket;
+        this.headSize = opts.headSize;
+        this.closeMethod = opts.closeMethod;
+        this.headBuffer = Buffer.alloc(opts.headSize);
+        this.headHandler = opts.headHandler;
+
+        this.headOffset = 0;
+        this.packageOffset = 0;
+        this.packageSize = 0;
+        this.packageBuffer = null;
+
+        // bind event form the origin socket
+        this._socket.on('data', this.ondata.bind(this));
+        this._socket.on('end', this.onend.bind(this));
+        this._socket.on('error', this.emit.bind(this, 'error'));
+        this._socket.on('close', this.emit.bind(this, 'close'));
+
+        this.state = ST_HEAD;
+    }
+
+
+    send(msg: any, options: { binary?: boolean }, cb?: (err ?: Error) => void) {
+        this._socket.write(msg, options.binary ? 'binary' : 'utf8', cb);
+    }
+
+    close() {
+        if (!!this.closeMethod && this.closeMethod === 'end') {
+            this._socket.end();
+        } else {
+            try {
+                this._socket.destroy();
+            } catch (e) {
+                logger.error('socket close with destroy error: %j', e.stack);
+            }
+        }
+    }
+
+    ondata(chunk: Buffer) {
+        if (this.state === ST_CLOSED) {
+            throw new Error('socket has closed');
+        }
+
+        if (typeof chunk !== 'string' && !Buffer.isBuffer(chunk)) {
+            throw new Error('invalid data');
+        }
+
+        if (typeof chunk === 'string') {
+            chunk = Buffer.from(chunk, 'utf8');
+        }
+
+        let offset = 0, end = chunk.length;
+
+        while (offset < end && this.state !== ST_CLOSED) {
+            if (this.state === ST_HEAD) {
+                offset = this.readHead(chunk, offset);
+            }
+
+            if (this.state === ST_BODY) {
+                offset = this.readBody(chunk, offset);
+            }
+        }
+
+        return true;
+    }
+
+    onend(chunk: Buffer) {
+        if (chunk) {
+            this._socket.write(chunk);
+        }
+
+        this.state = ST_CLOSED;
+        this.reset();
+        this.emit('end');
+    }
+
+    /**
+     * Read head segment from data to socket.headBuffer.
+     *
+     * @param  {Object} socket Socket instance
+     * @param  {Object} data   Buffer instance
+     * @param  {Number} offset offset read star from data
+     * @return {Number}        new offset of data after read
+     */
+    readHead(data: Buffer, offset: number) {
+        let hlen = this.headSize - this.headOffset;
+        let dlen = data.length - offset;
+        let len = Math.min(hlen, dlen);
+        let dend = offset + len;
+
+        data.copy(this.headBuffer, this.headOffset, offset, dend);
+        this.headOffset += len;
+
+        if (this.headOffset === this.headSize) {
+            // if head segment finished
+            let size = this.headHandler(this.headBuffer);
+            if (size < 0) {
+                throw new Error('invalid body size: ' + size);
+            }
+            // check if header contains a valid type
+            if (checkTypeData(this.headBuffer[0])) {
+                this.packageSize = size + this.headSize;
+                this.packageBuffer = Buffer.alloc(this.packageSize);
+                this.headBuffer.copy(this.packageBuffer, 0, 0, this.headSize);
+                this.packageOffset = this.headSize;
+                this.state = ST_BODY;
+            } else {
+                dend = data.length;
+                logger.error('close the connection with invalid head message, the remote ip is %s && port is %s && message is %j', this._socket.remoteAddress, this._socket.remotePort, data);
+                this.close();
+            }
+
+        }
+
+        return dend;
+    }
+
+    /**
+     * Read body segment from data buffer to socket.packageBuffer;
+     *
+     * @param  {Object} socket Socket instance
+     * @param  {Object} data   Buffer instance
+     * @param  {Number} offset offset read star from data
+     * @return {Number}        new offset of data after read
+     */
+    readBody(data: Buffer, offset: number) {
+        let blen = this.packageSize - this.packageOffset;
+        let dlen = data.length - offset;
+        let len = Math.min(blen, dlen);
+        let dend = offset + len;
+
+        data.copy(this.packageBuffer, this.packageOffset, offset, dend);
+
+        this.packageOffset += len;
+
+        if (this.packageOffset === this.packageSize) {
+            // if all the package finished
+            let buffer = this.packageBuffer;
+            this.emit('message', buffer);
+            this.reset();
+        }
+
+        return dend;
+    }
+
+    reset() {
+        this.headOffset = 0;
+        this.packageOffset = 0;
+        this.packageSize = 0;
+        this.packageBuffer = null;
+        this.state = ST_HEAD;
+    }
+
+}
+
+let checkTypeData = function (data: number) {
+    return data === Package.TYPE_HANDSHAKE || data === Package.TYPE_HANDSHAKE_ACK || data === Package.TYPE_HEARTBEAT || data === Package.TYPE_DATA || data === Package.TYPE_KICK;
+};

package/lib/connectors/hybrid/wsprocessor.ts

@@ -0,0 +1,57 @@
+import { Server as HttpServer } from 'http';
+import { EventEmitter } from 'events';
+import * as util from 'util';
+import * as net from 'net';
+import * as WebSocket from 'ws';
+
+let ST_STARTED = 1;
+let ST_CLOSED = 2;
+
+/**
+ * websocket protocol processor
+ */
+export class WSProcessor extends EventEmitter {
+    httpServer: HttpServer;
+    wsServer: WebSocket.Server;
+    state: number;
+
+    constructor() {
+        super();
+        this.httpServer = new HttpServer();
+
+        let self = this;
+        this.wsServer = new WebSocket.Server({ server: this.httpServer });
+
+        this.wsServer.on('connection', function (socket, request) {
+            // emit socket to outside
+            self.emit('connection', socket, request);
+        });
+
+        this.state = ST_STARTED;
+    }
+
+
+    add(socket: net.Socket, data: Buffer) {
+        if (this.state !== ST_STARTED) {
+            return;
+        }
+        this.httpServer.emit('connection', socket);
+        if (typeof (socket as any).ondata === 'function') {
+            // compatible with stream2
+            (socket as any).ondata(data, 0, data.length);
+        } else {
+            // compatible with old stream
+            socket.emit('data', data);
+        }
+    }
+
+    close() {
+        if (this.state !== ST_STARTED) {
+            return;
+        }
+        this.state = ST_CLOSED;
+        this.wsServer.close();
+        this.wsServer = null;
+        this.httpServer = null;
+    }
+}

package/lib/connectors/hybridconnector.ts

@@ -0,0 +1,134 @@
+import * as net from 'net';
+import * as tls from 'tls';
+import * as util from 'util';
+import { EventEmitter } from 'events';
+
+import { HybridSocket } from './hybridsocket';
+import { HybridSwitcher as Switcher, HybridSwitcherOptions } from './hybrid/switcher';
+import { HandshakeCommand } from './commands/handshake';
+import { HeartbeatCommand } from './commands/heartbeat';
+import * as Kick from './commands/kick';
+import * as coder from './common/coder';
+import { ConnectorComponent } from '../components/connector';
+import { DictionaryComponent } from '../components/dictionary';
+import { ProtobufComponent } from '../components/protobuf';
+import { IComponent } from '../interfaces/IComponent';
+import { melo } from '../melo';
+import { IConnector } from '../interfaces/IConnector';
+import { TlsOptions } from 'tls';
+import * as WebSocket from 'ws';
+import { TcpSocket } from './hybrid/tcpsocket';
+import { IHybridSocket } from './hybrid/IHybridSocket';
+
+let curId = 1;
+
+export interface HybridConnectorOptions extends HybridSwitcherOptions {
+    useDict?: boolean;
+    useProtobuf?: boolean;
+    distinctHost?: boolean;
+    realIPKey?: string;   // 代理过后真实客户端ip获取字段
+    realPortKey?: string; // 代理过后真实客户端port获取字段
+}
+
+/**
+ * Connector that manager low level connection and protocol bewteen server and client.
+ * Develper can provide their own connector to switch the low level prototol, such as tcp or probuf.
+ */
+export class HybridConnector extends EventEmitter implements IConnector {
+    opts: HybridConnectorOptions;
+    port: number;
+    host: string;
+    useDict: boolean;
+    useProtobuf: boolean;
+    handshake: HandshakeCommand;
+    heartbeat: HeartbeatCommand;
+    distinctHost: boolean;
+    ssl: tls.TlsOptions;
+    switcher: Switcher;
+
+    connector: IConnector;
+    dictionary: DictionaryComponent;
+    protobuf: ProtobufComponent;
+    decodeIO_protobuf: IComponent;
+
+    listeningServer: net.Server | tls.Server;
+
+    constructor(port: number, host: string, opts?: HybridConnectorOptions) {
+        super();
+
+        this.opts = opts || {};
+        if (this.opts.realPortKey) {
+            this.opts.realPortKey = opts.realPortKey.toLowerCase();
+        }
+        if (this.opts.realIPKey) {
+            this.opts.realIPKey = opts.realIPKey.toLowerCase();
+        }
+        this.port = port;
+        this.host = host;
+        this.useDict = opts.useDict;
+        this.useProtobuf = opts.useProtobuf;
+        this.handshake = new HandshakeCommand(opts);
+        this.heartbeat = new HeartbeatCommand(opts);
+        this.distinctHost = opts.distinctHost;
+        this.ssl = opts.ssl;
+
+        this.switcher = null;
+    }
+
+    /**
+     * Start connector to listen the specified port
+     */
+    start(cb: () => void) {
+        let app = melo.app;
+        let self = this;
+
+        let gensocket = function (socket: IHybridSocket, request: any) {
+            let hybridsocket = new HybridSocket(curId++, socket, request, self.opts);
+            hybridsocket.on('handshake', self.handshake.handle.bind(self.handshake, hybridsocket));
+            hybridsocket.on('heartbeat', self.heartbeat.handle.bind(self.heartbeat, hybridsocket));
+            hybridsocket.on('disconnect', self.heartbeat.clear.bind(self.heartbeat, hybridsocket.id));
+            hybridsocket.on('closing', Kick.handle.bind(null, hybridsocket));
+            self.emit('connection', hybridsocket);
+        };
+
+        this.connector = app.components.__connector__.connector;
+        this.dictionary = app.components.__dictionary__;
+        this.protobuf = app.components.__protobuf__;
+        this.decodeIO_protobuf = app.components.__decodeIO__protobuf__;
+
+        if (!this.ssl) {
+            this.listeningServer = net.createServer();
+        } else {
+            this.listeningServer = tls.createServer(this.ssl);
+            if (this.opts.sslWatcher) {
+                this.opts.sslWatcher((opts) => {
+                    (this.listeningServer as tls.Server).setSecureContext(opts);
+                });
+            }
+        }
+        this.switcher = new Switcher(this.listeningServer, self.opts);
+
+        this.switcher.on('connection', function (socket, request) {
+            gensocket(socket, request);
+        });
+
+        if (!!this.distinctHost) {
+            this.listeningServer.listen(this.port, this.host);
+        } else {
+            this.listeningServer.listen(this.port);
+        }
+
+        process.nextTick(cb);
+    }
+
+    stop(force: boolean, cb: () => void) {
+        this.switcher.close();
+        this.listeningServer.close();
+
+        process.nextTick(cb);
+    }
+    decode = coder.decode;
+
+    encode = coder.encode;
+
+}