ij-rpc-client/out/rpc-node.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const net = require("net");
const rpc_1 = require("./rpc");
const debug = require("debug")("rpc");
function connect(port = 63342, domains = null) {
    const transport = new SocketTransport();
    const server = new rpc_1.JsonRpc(transport, domains);
    transport.connect(port);
    return server;
}
exports.connect = connect;
class SocketTransport {
    constructor(socket = new net.Socket()) {
        this.socket = socket;
    }
    connect(port = 63342) {
        this.socket.connect(port, null, () => {
            debug("Connected to %s", port);
            const opened = this.opened;
            if (opened != null) {
                opened();
            }
        });
        this.socket.on("error", (e) => {
            console.error(e);
        });
        const messageReceived = this.messageReceived;
        if (messageReceived == null) {
            console.warn("messageReceived is not specified, input will be ignored");
        }
        else {
            const messageDecoder = new MessageDecoder(messageReceived);
            this.socket.on("data", messageDecoder.messageReceived.bind(messageDecoder));
        }
        this.socket.write(new Buffer([67, 72, 105, -107, 126, -21, -81, -72, 64, 54, -87, -88, 0, -46, -48, 34, -7, -67]));
    }
    send(id, domain, command, params = null) {
        const encodedParams = params == null || params.length === 0 ? null : JSON.stringify(params);
        const header = '[' + (id == -1 ? '' : (id + ', ')) + '"' + domain + '", "' + command + '"';
        const headerBuffer = new Buffer(4);
        headerBuffer.writeUInt32BE(header.length + (encodedParams == null ? 0 : Buffer.byteLength(encodedParams)) + 1, 0);
        this.socket.write(headerBuffer);
        debug("out: %s%s]", header, encodedParams || "");
        this.socket.write(header);
        if (encodedParams != null) {
            this.socket.write(encodedParams);
        }
        this.socket.write(']');
    }
    sendResult(id, result) {
        this.sendResultOrError(id, result, false);
    }
    sendError(id, error) {
        this.sendResultOrError(id, error, true);
    }
    sendResultOrError(id, result, isError) {
        var encodedResult = JSON.stringify(result);
        var header = id + ', "' + (isError ? 'e' : 'r') + '"';
        const headerBuffer = new Buffer(4);
        headerBuffer.writeUInt32BE(Buffer.byteLength(encodedResult) + header.length, 0);
        this.socket.write(headerBuffer);
        this.socket.write(encodedResult);
    }
}
exports.SocketTransport = SocketTransport;
class MessageDecoder {
    constructor(messageProcessor) {
        this.messageProcessor = messageProcessor;
        this.state = 0;
        this.contentLength = 0;
        this.buffers = [];
        this.readableByteCount = 0;
        this.messageBufferOffset = 0;
    }
    concatBuffer(buffer) {
        if (this.buffers.length === 0) {
            return buffer;
        }
        this.buffers.push(buffer);
        let totalBuffer = Buffer.concat(this.buffers, this.readableByteCount);
        this.buffers.length = 0;
        return totalBuffer;
    }
    messageReceived(buffer) {
        let offset = 0;
        this.readableByteCount += buffer.length;
        while (true) {
            switch (this.state) {
                case 0: {
                    if (this.readableByteCount < 4) {
                        if (offset != 0) {
                            buffer = buffer.slice(offset);
                        }
                        this.buffers.push(buffer);
                        return;
                    }
                    buffer = this.concatBuffer(buffer);
                    this.state = 1;
                    this.contentLength = buffer.readUInt32BE(offset);
                    offset += 4;
                    if ((buffer.length - offset) < this.contentLength) {
                        this.messageBuffer = new Buffer(this.contentLength);
                        buffer.copy(this.messageBuffer, 0, offset);
                        this.messageBufferOffset = 0;
                        this.readableByteCount = 0;
                        return;
                    }
                    this.readableByteCount = buffer.length - offset;
                }
                case 1: {
                    let rawMessage;
                    if (this.messageBuffer == null) {
                        rawMessage = buffer.toString("utf8", offset, offset + this.contentLength);
                        offset += this.contentLength;
                        this.readableByteCount = buffer.length - offset;
                    }
                    else {
                        const requiredByteCount = this.messageBuffer.length - this.messageBufferOffset;
                        if (requiredByteCount > this.readableByteCount) {
                            buffer.copy(this.messageBuffer, this.messageBufferOffset, offset);
                            this.messageBufferOffset += this.readableByteCount;
                            this.readableByteCount = 0;
                            return;
                        }
                        else {
                            const newOffset = offset + requiredByteCount;
                            buffer.copy(this.messageBuffer, this.messageBufferOffset, offset, newOffset);
                            offset = newOffset;
                            this.readableByteCount = buffer.length - offset;
                            rawMessage = this.messageBuffer.toString("utf8");
                        }
                    }
                    debug("in: %s", rawMessage);
                    try {
                        this.state = 0;
                        this.contentLength = 0;
                        this.messageProcessor(JSON.parse(rawMessage));
                    }
                    catch (e) {
                        console.error("Error: %s,\nInput: %s", e, rawMessage);
                    }
                }
            }
        }
    }
}
//# sourceMappingURL=rpc-node.js.map