node-hca/lib/Connection/Connection.js

Node.js client for HCA

'use strict';

var util = require('util'),
    EventEmitter = require('events').EventEmitter,
    W3CWebSocket = require('websocket').w3cwebsocket,
    HcaResponse = require('../Messaging/HcaResponse'),
    message = require('../Messaging/message');

(function () {

    var self,
        socketUri = "ws://%s:%d/hca",
        socket;

    var Connection = function (host, port) {

        if (!host) {
            throw Error('Host parameter is required.');
        }

        if (!port || parseInt(port) <= 0) {
            throw Error('Port parameter is required, and must be greater than zero (0).');
        }

        EventEmitter.call(this);

        self = this;

        this.host = host;
        this.port = port;

        this.topics = {
            connectionOpened: 'Connection:Opened',
            connectionClosed: 'Connection:Closed',
            connectionError: 'Connection:Error',
            messageSent: 'Connection:MessageSent',
            messageReceived: 'Connection:MessageReceived',
            handshakeCompleted: 'Connection:HandshakeCompleted'
        };
    };

    util.inherits(Connection, EventEmitter);

    Connection.prototype.connect = function () {

        if (socket && socket.readyState != 3) { // connection already opened
            return;
        }

        var uri = util.format(socketUri, this.host, parseInt(this.port));

        util.log('[CON] Connecting to: ' + uri + ' ...');

        socket = new W3CWebSocket(uri);

        socket.onopen = function (e) {
            onOpen(e);
        };

        socket.onmessage = function (e) {
            onMessage(e);
        };

        socket.onclose = function (e) {
            onClose(e);
        };

        socket.onerror = function (e) {
            onError(e);
        };
    };

    Connection.prototype.disconnect = function () {
        if (!socket || socket.readyState != 1) { // connection already closed
            return;
        };

        util.log('[CON] Closing connection.');
        socket.close();
    };

    Connection.prototype.send = function (params) {
        if (util.isArray(params))
            params = message.encode(params);

        if (!socket || socket.readyState != 1) { // connection not available
            util.log("[CON] Connection not available/ready to send message. (%s)", params);
            return;
        };

        socket.send(params);

        // Sanitize password.
        if (params.indexOf('SetPassword') > -1) {
            const index = params.indexOf('SetPassword');
            params = params.substring(0, index + 12) + '<<sanitized>>';
        }

        self.emit(self.topics.messageSent, params);
    };

    var onOpen = function (e) {
        self.emit(self.topics.connectionOpened, e);
    };

    var onClose = function (e) {
        self.emit(self.topics.connectionClosed, e);
    };

    var onError = function (e) {
        self.emit(self.topics.connectionError, e);
    };

    var onMessage = function (e) {
        if (e.data.indexOf("HCA") == 0) { // Initial handshake.
            self.emit(self.topics.messageReceived, e.data);
            self.emit(self.topics.handshakeCompleted, e);
            return;
        }

        var response = message.parse(e.data);

        if (response instanceof HcaResponse) {
            self.emit(self.topics.messageReceived, response);
            self.emit(response.command, response);
        }
    };

    module.exports = Connection;

})();