@bigtyphoon/melo 1.7.6

package/lib/connectors/hybridsocket.ts

@@ -0,0 +1,168 @@
+import * as util from 'util';
+import * as net from 'net';
+import { EventEmitter } from 'events';
+import { default as handler } from './common/handler';
+import { Package } from '@bigtyphoon/melo-protocol';
+import { getLogger } from '@bigtyphoon/melo-logger';
+import { ISocket } from '../interfaces/ISocket';
+import * as WebSocket from 'ws';
+import { TcpSocket } from './hybrid/tcpsocket';
+import { IHybridSocket } from './hybrid/IHybridSocket';
+import * as path from 'path';
+
+let logger = getLogger('melo', path.basename(__filename));
+
+
+let ST_INITED = 0;
+let ST_WAIT_ACK = 1;
+let ST_WORKING = 2;
+let ST_CLOSED = 3;
+
+export interface HybridSocketOptions {
+    realIPKey?: string;   // 代理过后真实客户端ip获取字段 Header name must be lower-cased.
+    realPortKey?: string; // 代理过后真实客户端port获取字段 Header name must be lower-cased.
+}
+
+/**
+ * Socket class that wraps socket and websocket to provide unified interface for up level.
+ */
+export class HybridSocket extends EventEmitter implements ISocket {
+    id: number;
+    socket: IHybridSocket;
+    remoteAddress: { ip: string, port: number };
+    state: number;
+
+    constructor(id: number, socket: IHybridSocket, request: any, opts: HybridSocketOptions) {
+        super();
+        this.id = id;
+        this.socket = socket;
+
+        if (request && (opts.realIPKey || opts.realPortKey)) {
+            let ip = request['headers'][opts.realIPKey];
+            if (ip) {
+                this.remoteAddress = {
+                    ip: ip,
+                    port: opts.realPortKey ? request['headers'][opts.realPortKey] : 0
+                }
+            }
+        }
+        if (!this.remoteAddress) {
+            if (!(socket as TcpSocket)._socket) {
+                this.remoteAddress = {
+                    ip: (socket as any).address().address,
+                    port: (socket as any).address().port
+                };
+            } else {
+                this.remoteAddress = {
+                    ip: (socket as TcpSocket)._socket.remoteAddress,
+                    port: (socket as TcpSocket)._socket.remotePort
+                };
+            }
+        }
+
+        let self = this;
+
+        socket.once('close', this.emit.bind(this, 'disconnect'));
+        socket.on('error', this.emit.bind(this, 'error'));
+
+        socket.on('message', function (msg) {
+            if (msg) {
+                msg = Package.decode(msg);
+                handler(self, msg);
+            }
+        });
+
+        this.state = ST_INITED;
+
+        // TODO: any other events?
+    }
+
+
+    /**
+     * Send raw byte data.
+     *
+     * @api private
+     */
+    sendRaw(msg: any) {
+        if (this.state !== ST_WORKING) {
+            return;
+        }
+        let self = this;
+
+        this.socket.send(msg, { binary: true }, (err) => {
+            if (!!err) {
+                logger.error('websocket send binary data failed: %j', err.stack);
+                return;
+            }
+        });
+    }
+
+    /**
+     * Send byte data package to client.
+     *
+     * @param  {Buffer} msg byte data
+     */
+    send(msg: any) {
+        if (msg instanceof String) {
+            msg = Buffer.from(msg as string);
+        } else if (!(msg instanceof Buffer)) {
+            msg = Buffer.from(JSON.stringify(msg));
+        }
+        this.sendRaw(Package.encode(Package.TYPE_DATA, msg));
+    }
+
+    /**
+     * Send byte data packages to client in batch.
+     *
+     * @param  {Buffer} msgs byte data
+     */
+    sendBatch(msgs: any[]) {
+        let rs = [];
+        for (let i = 0; i < msgs.length; i++) {
+            let src = Package.encode(Package.TYPE_DATA, msgs[i]);
+            rs.push(src);
+        }
+        this.sendRaw(Buffer.concat(rs));
+    }
+
+    /**
+     * Send message to client no matter whether handshake.
+     *
+     * @api private
+     */
+    sendForce(msg: any) {
+        if (this.state === ST_CLOSED) {
+            return;
+        }
+        this.socket.send(msg, { binary: true });
+    }
+
+    /**
+     * Response handshake request
+     *
+     * @api private
+     */
+    handshakeResponse(resp: any) {
+        if (this.state !== ST_INITED) {
+            return;
+        }
+
+        this.socket.send(resp, { binary: true });
+        this.state = ST_WAIT_ACK;
+    }
+
+    /**
+     * Close the connection.
+     *
+     * @api private
+     */
+    disconnect() {
+        if (this.state === ST_CLOSED) {
+            return;
+        }
+
+        this.state = ST_CLOSED;
+        this.socket.emit('close');
+        this.socket.close();
+    }
+}

package/lib/connectors/mqtt/generate.ts

@@ -0,0 +1,103 @@
+import * as protocol from './protocol';
+import * as  crypto from 'crypto';
+
+/* TODO: consider rewriting these functions using buffers instead
+ * of arrays
+ */
+
+/* Publish */
+export function publish(opts: any) {
+    opts = opts || {};
+    let dup = opts.dup ? protocol.DUP_MASK : 0;
+    let qos = opts.qos || 0;
+    let retain = opts.retain ? protocol.RETAIN_MASK : 0;
+    let topic = opts.topic;
+    let payload = opts.payload || Buffer.alloc(0);
+    let id = (typeof opts.messageId === 'undefined') ? randint() : opts.messageId;
+    let packet = { header: 0, payload: [] as any[] };
+
+    /* Check required fields */
+    if (typeof topic !== 'string' || topic.length <= 0) return null;
+    /* if payload is a string, we'll convert it into a buffer */
+    if (typeof payload === 'string') {
+        payload = Buffer.from(payload);
+    }
+    /* accepting only a buffer for payload */
+    if (!Buffer.isBuffer(payload)) return null;
+    if (typeof qos !== 'number' || qos < 0 || qos > 2) return null;
+    if (typeof id !== 'number' || id < 0 || id > 0xFFFF) return null;
+
+    /* Generate header */
+    packet.header = protocol.codes.publish << protocol.CMD_SHIFT | dup | qos << protocol.QOS_SHIFT | retain;
+
+    /* Topic name */
+    packet.payload = packet.payload.concat(gen_string(topic));
+
+    /* Message ID */
+    if (qos > 0) packet.payload = packet.payload.concat(gen_number(id));
+
+
+    let buf = Buffer.from([packet.header]
+        .concat(gen_length(packet.payload.length + payload.length))
+        .concat(packet.payload));
+
+    return Buffer.concat([buf, payload]);
+}
+
+/* Requires length be a number > 0 */
+let gen_length = function (length: number) {
+    if (typeof length !== 'number') return null;
+    if (length < 0) return null;
+
+    let len = [];
+    let digit = 0;
+
+    do {
+        digit = length % 128 | 0;
+        length = length / 128 | 0;
+        if (length > 0) {
+            digit = digit | 0x80;
+        }
+        len.push(digit);
+    } while (length > 0);
+
+    return len;
+};
+
+let gen_string = function (str: string, without_length ?: boolean) { /* based on code in (from http://farhadi.ir/downloads/utf8.js) */
+    if (arguments.length < 2) without_length = false;
+    if (typeof str !== 'string') return null;
+    if (typeof without_length !== 'boolean') return null;
+
+    let nums: number[] = [];
+    let length = 0;
+    for (let i = 0; i < str.length; i++) {
+        let code = str.charCodeAt(i);
+        if (code < 128) {
+            nums.push(code); ++length;
+
+        } else if (code < 2048) {
+            nums.push(192 + ((code >> 6))); ++length;
+            nums.push(128 + ((code) & 63)); ++length;
+        } else if (code < 65536) {
+            nums.push(224 + ((code >> 12))); ++length;
+            nums.push(128 + ((code >> 6) & 63)); ++length;
+            nums.push(128 + ((code) & 63)); ++length;
+        } else if (code < 2097152) {
+            nums.push(240 + ((code >> 18))); ++length;
+            nums.push(128 + ((code >> 12) & 63)); ++length;
+            nums.push(128 + ((code >> 6) & 63)); ++length;
+            nums.push(128 + ((code) & 63)); ++length;
+        } else {
+            throw new Error('Can\'t encode character with code ' + code);
+        }
+    }
+    return without_length ? nums : gen_number(length).concat(nums);
+};
+
+let gen_number = function (num: number) {
+    let nums: number[] = [num >> 8, num & 0x00FF];
+    return nums;
+};
+
+let randint = function () { return Math.floor(Math.random() * 0xFFFF); };

package/lib/connectors/mqtt/mqttadaptor.ts

@@ -0,0 +1,114 @@
+
+
+import { MQTTSocket } from '../mqttsocket';
+export interface MqttAdaptorOptions {
+    publishRoute ?: string;
+    subscribeRoute ?: string;
+
+}
+export interface SubscribePacket {
+    messageId: number;
+    subscriptions: { topic: string, qos: number }[];
+}
+
+export interface PublishPacket {
+    topic: string;
+    payload: any;
+    messageId: number;
+    qos: number;
+}
+
+export class MqttAdaptor {
+    subReqs: {[messageId: number]: SubscribePacket} = {};
+    publishRoute: string;
+    subscribeRoute: string;
+    constructor(opts ?: MqttAdaptorOptions) {
+        opts = opts || {};
+        this.publishRoute = opts.publishRoute;
+        this.subscribeRoute = opts.subscribeRoute;
+    }
+
+    onPublish(client: MQTTSocket, packet: PublishPacket) {
+        let route = this.publishRoute;
+
+        if (!route) {
+            throw new Error('unspecified publish route.');
+        }
+
+        let payload = packet.payload;
+        if (payload instanceof Buffer) {
+            payload = payload.toString('utf8');
+        }
+
+        let req = {
+            id: packet.messageId,
+            route: route,
+            body: packet
+        };
+
+        client.emit('message', req);
+
+        if (packet.qos === 1) {
+            client.socket.puback({ messageId: packet.messageId });
+        }
+    }
+
+    onSubscribe(client: MQTTSocket, packet: SubscribePacket) {
+        let route = this.subscribeRoute;
+
+        if (!route) {
+            throw new Error('unspecified subscribe route.');
+        }
+
+        let req = {
+            id: packet.messageId,
+            route: route,
+            body: {
+                subscriptions: packet.subscriptions
+            }
+        };
+
+        this.subReqs[packet.messageId] = packet;
+
+        client.emit('message', req);
+    }
+
+    onPubAck(client: MQTTSocket, packet: SubscribePacket) {
+        let req = {
+            id: packet.messageId,
+            route: 'connector.mqttHandler.pubAck',
+            body: {
+                mid: packet.messageId
+            }
+        };
+
+        this.subReqs[packet.messageId] = packet;
+
+        client.emit('message', req);
+    }
+
+    /**
+     * Publish message or subscription ack.
+     *
+     * if packet.id exist and this.subReqs[packet.id] exist then packet is a suback.
+     * Subscription is request/response mode.
+     * packet.id is pass from client in packet.messageId and record in Melo context and attached to the subscribe response packet.
+     * packet.body is the context that returned by subscribe next callback.
+     *
+     * if packet.id not exist then packet is a publish message.
+     *
+     * otherwise packet is a illegal packet.
+     */
+    publish(client: MQTTSocket, packet: {id: number , body: any}) {
+        let mid = packet.id;
+        let subreq = this.subReqs[mid];
+        if (subreq) {
+            // is suback
+            client.socket.suback({ messageId: mid, granted: packet.body });
+            delete this.subReqs[mid];
+            return;
+        }
+
+        client.socket.publish(packet.body);
+    }
+}

package/lib/connectors/mqtt/protocol.ts

@@ -0,0 +1,49 @@
+/* Protocol - protocol constants */
+
+/* Command code => mnemonic */
+export let types = {
+  0: 'reserved',
+  1: 'connect',
+  2: 'connack',
+  3: 'publish',
+  4: 'puback',
+  5: 'pubrec',
+  6: 'pubrel',
+  7: 'pubcomp',
+  8: 'subscribe',
+  9: 'suback',
+  10: 'unsubscribe',
+  11: 'unsuback',
+  12: 'pingreq',
+  13: 'pingresp',
+  14: 'disconnect',
+  15: 'reserved'
+};
+
+/* Mnemonic => Command code */
+export let codes: {[key: string]: number} = {};
+for(let k in types) {
+  let v = (types as any)[k];
+  codes[v] = Number(k);
+}
+
+/* Header */
+export let CMD_SHIFT = 4;
+export let CMD_MASK = 0xF0;
+export let DUP_MASK = 0x08;
+export let QOS_MASK = 0x03;
+export let QOS_SHIFT = 1;
+export let RETAIN_MASK = 0x01;
+
+/* Length */
+export let LENGTH_MASK = 0x7F;
+export let LENGTH_FIN_MASK = 0x80;
+
+/* Connect */
+export let USERNAME_MASK = 0x80;
+export let PASSWORD_MASK = 0x40;
+export let WILL_RETAIN_MASK = 0x20;
+export let WILL_QOS_MASK = 0x18;
+export let WILL_QOS_SHIFT = 3;
+export let WILL_FLAG_MASK = 0x04;
+export let CLEAN_SESSION_MASK = 0x02;

package/lib/connectors/mqttconnector.ts

@@ -0,0 +1,134 @@
+import * as util from 'util';
+import { EventEmitter } from 'events';
+import * as net from 'net';
+import * as constants from '../util/constants';
+import { MQTTSocket } from './mqttsocket';
+import { MqttAdaptor } from './mqtt/mqttadaptor';
+import * as generate from './mqtt/generate';
+import { getLogger } from '@bigtyphoon/melo-logger';
+import { IConnector } from '../interfaces/IConnector';
+import * as path from 'path';
+import { MqttConnectionConstructor } from '@bigtyphoon/melo-admin';
+let logger = getLogger('melo', path.basename(__filename));
+const mqtt_connection: MqttConnectionConstructor = require('mqtt-connection');
+
+
+export interface MQTTConnectorOptions {
+    publishRoute ?: string;
+    subscribeRoute ?: string;
+}
+
+let curId = 1;
+/**
+ * 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 MQTTConnector extends EventEmitter implements IConnector {
+
+    port: number;
+    host: string;
+    opts: any;
+    adaptor: MqttAdaptor;
+    server: net.Server;
+    constructor(port: number, host: string, opts ?: MQTTConnectorOptions) {
+        super();
+        this.port = port;
+        this.host = host;
+        this.opts = opts || {};
+
+        this.adaptor = new MqttAdaptor(this.opts);
+    }
+
+    /**
+     * Start connector to listen the specified port
+     */
+    start(cb: () => void) {
+        let self = this;
+        this.server = new net.Server();
+        this.server.listen(this.port);
+        logger.info('[MQTTConnector] listen on %d', this.port);
+
+        this.server.on('error', function (err) {
+            // logger.error('mqtt server is error: %j', err.stack);
+            self.emit('error', err);
+        });
+
+        this.server.on('connection', (stream) => {
+            let client = mqtt_connection(stream);
+
+            client.on('error', function (err: Error) {
+                client.destroy();
+            });
+
+            client.on('close', function () {
+                client.destroy();
+            });
+
+            client.on('disconnect', function (packet: any) {
+                client.destroy();
+            });
+            // stream timeout
+            stream.on('timeout', function () { client.destroy(); });
+            // client published
+            client.on('publish', function (packet: any) {
+                // send a puback with messageId (for QoS > 0)
+                client.puback({ messageId: packet.messageId });
+            });
+            // client pinged
+            client.on('pingreq', function () {
+                // send a pingresp
+                client.pingresp();
+            });
+
+            if (self.opts.disconnectOnTimeout) {
+                let timeout = self.opts.timeout * 1000 || constants.TIME.DEFAULT_MQTT_HEARTBEAT_TIMEOUT;
+                stream.setTimeout(timeout, function () {
+                    client.destroy();
+                    client.emit('close');
+                });
+            }
+
+            client.on('connect', function (packet: any) {
+                client.connack({ returnCode: 0 });
+                let mqttsocket = new MQTTSocket(curId++, client, self.adaptor);
+                self.emit('connection', mqttsocket);
+            });
+        });
+
+
+        process.nextTick(cb);
+    }
+
+    stop() {
+        this.server.close();
+        process.exit(0);
+    }
+
+
+    encode(reqId: number, route: string, msgBody: any) {
+        if (!!reqId) {
+            return composeResponse(reqId, route, msgBody);
+        } else {
+            return composePush(route, msgBody);
+        }
+    }
+
+    close() {
+        this.server.close();
+    }
+}
+let composeResponse = function (msgId: number, route: string, msgBody: any) {
+    return {
+        id: msgId,
+        body: msgBody
+    };
+};
+
+let composePush = function (route: string, msgBody: any) {
+    let msg = generate.publish(msgBody);
+    if (!msg) {
+        logger.error('invalid mqtt publish message: %j', msgBody);
+    }
+
+    return msg;
+};

package/lib/connectors/mqttsocket.ts

@@ -0,0 +1,79 @@
+import * as util from 'util';
+import { EventEmitter } from 'events';
+import { ISocket } from '../interfaces/ISocket';
+import { MqttAdaptor } from './mqtt/mqttadaptor';
+import { MqttConnection } from '@bigtyphoon/melo-admin';
+
+let ST_INITED = 1;
+let ST_CLOSED = 2;
+
+/**
+ * Socket class that wraps socket and websocket to provide unified interface for up level.
+ */
+export class MQTTSocket extends EventEmitter implements ISocket {
+    id: number;
+    socket: MqttConnection;
+    remoteAddress: { ip: string, port: number };
+    adaptor: MqttAdaptor;
+
+    state: number;
+
+    constructor(id: number, socket: MqttConnection, adaptor: MqttAdaptor) {
+        super();
+        this.id = id;
+        this.socket = socket;
+        this.remoteAddress = {
+            ip: socket.stream.remoteAddress,
+            port: socket.stream.remotePort
+        };
+        this.adaptor = adaptor;
+
+        let self = this;
+
+        socket.on('close', this.emit.bind(this, 'disconnect'));
+        socket.on('error', this.emit.bind(this, 'disconnect'));
+        socket.on('disconnect', this.emit.bind(this, 'disconnect'));
+
+        socket.on('pingreq', function (packet: any) {
+            socket.pingresp();
+        });
+
+        socket.on('subscribe', this.adaptor.onSubscribe.bind(this.adaptor, this));
+
+        socket.on('publish', this.adaptor.onPublish.bind(this.adaptor, this));
+
+        this.state = ST_INITED;
+
+        // TODO: any other events?
+    }
+
+
+    send(msg: any) {
+        if (this.state !== ST_INITED) {
+            return;
+        }
+        if (msg instanceof Buffer) {
+            // if encoded, send directly
+            this.socket.stream.write(msg);
+        } else {
+            this.adaptor.publish(this, msg);
+        }
+    }
+
+    sendRaw = this.send;
+
+    sendBatch(msgs: any[]) {
+        for (let i = 0, l = msgs.length; i < l; i++) {
+            this.send(msgs[i]);
+        }
+    }
+
+    disconnect() {
+        if (this.state === ST_CLOSED) {
+            return;
+        }
+
+        this.state = ST_CLOSED;
+        this.socket.stream.destroy();
+    }
+}