jarvisnode/modules/tcp/handler.js

A library written in Node.js used to communicate with my Jarvis project

var net = require('net');
var types = require('../types');
var tcp = require('./utils');
var util = require('util');
var bridge = require('../bridge');
var EventEmitter = require('events').EventEmitter;
var debug = require('debug')('jarvisnode:tcp');

function Handler() {};
util.inherits(Handler, EventEmitter);

Handler.prototype.start = function() {

  var self = this;

  self.emit('start');
};

Handler.prototype.connect = function() {

  var self = this;

  tcp.connect(function(err, buf) {

    if (err)
      return self.emit('registration-needed');

    return self._createAndWrite(buf);
  });
};

Handler.prototype.registerRequest = function() {

  var self = this;

  tcp.registerRequest(function(err, buf) {

    if (err)
      return console.log('Registration request failed - Error code: ' + err);

    return self._createAndWrite(buf);
  });
};

Handler.prototype._register = function() {

  var self = this;

  tcp.register(function(err, buf) {

    if (err)
      return console.log('Registration failed - Error code: ' + err);

    return self._createAndWrite(buf);
  });
};

Handler.prototype._createAndWrite = function(buf) {

  var self = this;
  var config = require('../config').get();

  if (!self.sock) {
    self.sock = new net.Socket();

    self.sock.on('data', function(data) {

      self._compute(data);
    });

    self.sock.on('error', function(err) {
      self._tryReconnect();
    });
    
    self.sock.on('close', function () {
      self._tryReconnect();
    });

    self.sock.connect(config.ports.J_TCP_PORT, config.J_IP);
  }

  self.sock.write(buf);
};

Handler.prototype._compute = function(data) {

  var self = this;

  switch(data[0]) {

    case types.messages.TCP.S.CONN_REQUEST:
      tcp.connectionResponse(data.slice(1), function(err) {

        if (err)
          self.emit('registration-needed');

        self.connecting = false;
        debug('Connected');
        self.emit('connected');
      });
      break;

    case types.messages.TCP.S.REGISTER_REQUEST:
      tcp.registerRequestResponse(data.slice(1), function(err) {

        if (err)
          return debug(err);

        self._register();
      });
      break;

    case types.messages.TCP.S.REGISTER:
      self.emit('registered');
      break;

    case types.messages.TCP.J.EXEC_COMMAND:
      bridge.emit('command', JSON.parse(data.slice(9)), function(res) {
        var resp = new Buffer(JSON.stringify(res));
        self.sock.write(resp, 0, resp.length);
      });
      break;
      
    case types.messages.TCP.J.REQUEST_STATE:
      bridge.emit('state', data[9], function(res) {
        var resp = new Buffer(JSON.stringify(res));
        self.sock.write(resp, 0, resp.length);
      });
      break;

    default:
      break;
    }
};

Handler.prototype._tryReconnect = function () {
  var self = this;
  self.sock = null;
  
  setTimeout(function () {
    if (!self.connecting) {
      debug('Connecting...');
      self.connecting = true;
    }
    self.connect();
  }, 1000);
}

module.exports = Handler;