@bigtyphoon/melo 1.7.6

package/dist/lib/connectors/hybrid/tcpsocket.js

@@ -0,0 +1,171 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TcpSocket = void 0;
+const stream_1 = require("stream");
+const melo_protocol_1 = require("@bigtyphoon/melo-protocol");
+const melo_logger_1 = require("@bigtyphoon/melo-logger");
+const path = require("path");
+let logger = (0, melo_logger_1.getLogger)('melo', path.basename(__filename));
+/**
+ * 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.
+ */
+class TcpSocket extends stream_1.Stream {
+    constructor(socket, opts) {
+        // 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, options, cb) {
+        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) {
+        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) {
+        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, offset) {
+        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, offset) {
+        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;
+    }
+}
+exports.TcpSocket = TcpSocket;
+let checkTypeData = function (data) {
+    return data === melo_protocol_1.Package.TYPE_HANDSHAKE || data === melo_protocol_1.Package.TYPE_HANDSHAKE_ACK || data === melo_protocol_1.Package.TYPE_HEARTBEAT || data === melo_protocol_1.Package.TYPE_DATA || data === melo_protocol_1.Package.TYPE_KICK;
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/connectors/hybrid/wsprocessor.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WSProcessor = void 0;
+const http_1 = require("http");
+const events_1 = require("events");
+const WebSocket = require("ws");
+let ST_STARTED = 1;
+let ST_CLOSED = 2;
+/**
+ * websocket protocol processor
+ */
+class WSProcessor extends events_1.EventEmitter {
+    constructor() {
+        super();
+        this.httpServer = new http_1.Server();
+        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, data) {
+        if (this.state !== ST_STARTED) {
+            return;
+        }
+        this.httpServer.emit('connection', socket);
+        if (typeof socket.ondata === 'function') {
+            // compatible with stream2
+            socket.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;
+    }
+}
+exports.WSProcessor = WSProcessor;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid3Nwcm9jZXNzb3IuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9saWIvY29ubmVjdG9ycy9oeWJyaWQvd3Nwcm9jZXNzb3IudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQUEsK0JBQTRDO0FBQzVDLG1DQUFzQztBQUd0QyxnQ0FBZ0M7QUFFaEMsSUFBSSxVQUFVLEdBQUcsQ0FBQyxDQUFDO0FBQ25CLElBQUksU0FBUyxHQUFHLENBQUMsQ0FBQztBQUVsQjs7R0FFRztBQUNILE1BQWEsV0FBWSxTQUFRLHFCQUFZO0lBS3pDO1FBQ0ksS0FBSyxFQUFFLENBQUM7UUFDUixJQUFJLENBQUMsVUFBVSxHQUFHLElBQUksYUFBVSxFQUFFLENBQUM7UUFFbkMsSUFBSSxJQUFJLEdBQUcsSUFBSSxDQUFDO1FBQ2hCLElBQUksQ0FBQyxRQUFRLEdBQUcsSUFBSSxTQUFTLENBQUMsTUFBTSxDQUFDLEVBQUUsTUFBTSxFQUFFLElBQUksQ0FBQyxVQUFVLEVBQUUsQ0FBQyxDQUFDO1FBRWxFLElBQUksQ0FBQyxRQUFRLENBQUMsRUFBRSxDQUFDLFlBQVksRUFBRSxVQUFVLE1BQU0sRUFBRSxPQUFPO1lBQ3BELHlCQUF5QjtZQUN6QixJQUFJLENBQUMsSUFBSSxDQUFDLFlBQVksRUFBRSxNQUFNLEVBQUUsT0FBTyxDQUFDLENBQUM7UUFDN0MsQ0FBQyxDQUFDLENBQUM7UUFFSCxJQUFJLENBQUMsS0FBSyxHQUFHLFVBQVUsQ0FBQztJQUM1QixDQUFDO0lBR0QsR0FBRyxDQUFDLE1BQWtCLEVBQUUsSUFBWTtRQUNoQyxJQUFJLElBQUksQ0FBQyxLQUFLLEtBQUssVUFBVSxFQUFFO1lBQzNCLE9BQU87U0FDVjtRQUNELElBQUksQ0FBQyxVQUFVLENBQUMsSUFBSSxDQUFDLFlBQVksRUFBRSxNQUFNLENBQUMsQ0FBQztRQUMzQyxJQUFJLE9BQVEsTUFBYyxDQUFDLE1BQU0sS0FBSyxVQUFVLEVBQUU7WUFDOUMsMEJBQTBCO1lBQ3pCLE1BQWMsQ0FBQyxNQUFNLENBQUMsSUFBSSxFQUFFLENBQUMsRUFBRSxJQUFJLENBQUMsTUFBTSxDQUFDLENBQUM7U0FDaEQ7YUFBTTtZQUNILDZCQUE2QjtZQUM3QixNQUFNLENBQUMsSUFBSSxDQUFDLE1BQU0sRUFBRSxJQUFJLENBQUMsQ0FBQztTQUM3QjtJQUNMLENBQUM7SUFFRCxLQUFLO1FBQ0QsSUFBSSxJQUFJLENBQUMsS0FBSyxLQUFLLFVBQVUsRUFBRTtZQUMzQixPQUFPO1NBQ1Y7UUFDRCxJQUFJLENBQUMsS0FBSyxHQUFHLFNBQVMsQ0FBQztRQUN2QixJQUFJLENBQUMsUUFBUSxDQUFDLEtBQUssRUFBRSxDQUFDO1FBQ3RCLElBQUksQ0FBQyxRQUFRLEdBQUcsSUFBSSxDQUFDO1FBQ3JCLElBQUksQ0FBQyxVQUFVLEdBQUcsSUFBSSxDQUFDO0lBQzNCLENBQUM7Q0FDSjtBQTVDRCxrQ0E0Q0MifQ==

package/dist/lib/connectors/hybridconnector.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HybridConnector = void 0;
+const net = require("net");
+const tls = require("tls");
+const events_1 = require("events");
+const hybridsocket_1 = require("./hybridsocket");
+const switcher_1 = require("./hybrid/switcher");
+const handshake_1 = require("./commands/handshake");
+const heartbeat_1 = require("./commands/heartbeat");
+const Kick = require("./commands/kick");
+const coder = require("./common/coder");
+const melo_1 = require("../melo");
+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.
+ */
+class HybridConnector extends events_1.EventEmitter {
+    constructor(port, host, opts) {
+        super();
+        this.decode = coder.decode;
+        this.encode = coder.encode;
+        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 handshake_1.HandshakeCommand(opts);
+        this.heartbeat = new heartbeat_1.HeartbeatCommand(opts);
+        this.distinctHost = opts.distinctHost;
+        this.ssl = opts.ssl;
+        this.switcher = null;
+    }
+    /**
+     * Start connector to listen the specified port
+     */
+    start(cb) {
+        let app = melo_1.melo.app;
+        let self = this;
+        let gensocket = function (socket, request) {
+            let hybridsocket = new hybridsocket_1.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.setSecureContext(opts);
+                });
+            }
+        }
+        this.switcher = new switcher_1.HybridSwitcher(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, cb) {
+        this.switcher.close();
+        this.listeningServer.close();
+        process.nextTick(cb);
+    }
+}
+exports.HybridConnector = HybridConnector;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/connectors/hybridsocket.js

@@ -0,0 +1,139 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HybridSocket = void 0;
+const events_1 = require("events");
+const handler_1 = require("./common/handler");
+const melo_protocol_1 = require("@bigtyphoon/melo-protocol");
+const melo_logger_1 = require("@bigtyphoon/melo-logger");
+const path = require("path");
+let logger = (0, melo_logger_1.getLogger)('melo', path.basename(__filename));
+let ST_INITED = 0;
+let ST_WAIT_ACK = 1;
+let ST_WORKING = 2;
+let ST_CLOSED = 3;
+/**
+ * Socket class that wraps socket and websocket to provide unified interface for up level.
+ */
+class HybridSocket extends events_1.EventEmitter {
+    constructor(id, socket, request, opts) {
+        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._socket) {
+                this.remoteAddress = {
+                    ip: socket.address().address,
+                    port: socket.address().port
+                };
+            }
+            else {
+                this.remoteAddress = {
+                    ip: socket._socket.remoteAddress,
+                    port: socket._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 = melo_protocol_1.Package.decode(msg);
+                (0, handler_1.default)(self, msg);
+            }
+        });
+        this.state = ST_INITED;
+        // TODO: any other events?
+    }
+    /**
+     * Send raw byte data.
+     *
+     * @api private
+     */
+    sendRaw(msg) {
+        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) {
+        if (msg instanceof String) {
+            msg = Buffer.from(msg);
+        }
+        else if (!(msg instanceof Buffer)) {
+            msg = Buffer.from(JSON.stringify(msg));
+        }
+        this.sendRaw(melo_protocol_1.Package.encode(melo_protocol_1.Package.TYPE_DATA, msg));
+    }
+    /**
+     * Send byte data packages to client in batch.
+     *
+     * @param  {Buffer} msgs byte data
+     */
+    sendBatch(msgs) {
+        let rs = [];
+        for (let i = 0; i < msgs.length; i++) {
+            let src = melo_protocol_1.Package.encode(melo_protocol_1.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) {
+        if (this.state === ST_CLOSED) {
+            return;
+        }
+        this.socket.send(msg, { binary: true });
+    }
+    /**
+     * Response handshake request
+     *
+     * @api private
+     */
+    handshakeResponse(resp) {
+        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();
+    }
+}
+exports.HybridSocket = HybridSocket;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/connectors/mqtt/generate.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.publish = void 0;
+const protocol = require("./protocol");
+/* TODO: consider rewriting these functions using buffers instead
+ * of arrays
+ */
+/* Publish */
+function publish(opts) {
+    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: [] };
+    /* 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]);
+}
+exports.publish = publish;
+/* Requires length be a number > 0 */
+let gen_length = function (length) {
+    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, without_length) {
+    if (arguments.length < 2)
+        without_length = false;
+    if (typeof str !== 'string')
+        return null;
+    if (typeof without_length !== 'boolean')
+        return null;
+    let nums = [];
+    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) {
+    let nums = [num >> 8, num & 0x00FF];
+    return nums;
+};
+let randint = function () { return Math.floor(Math.random() * 0xFFFF); };
+//# sourceMappingURL=data:application/json;base64,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