motion/lib/runner/bridge.js

motion - moving development forward

exports.__esModule = true;

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }

var _sbEventKit = require('sb-event-kit');

var _ws = require('ws');

var _libWport = require('./lib/wport');

var _libWport2 = _interopRequireDefault(_libWport);

var _cache = require('./cache');

var _cache2 = _interopRequireDefault(_cache);

var _libFns = require('./lib/fns');

var _opts = require('./opts');

var _opts2 = _interopRequireDefault(_opts);

exports['default'] = new ((function () {
  function Bridge() {
    _classCallCheck(this, Bridge);

    this.subscriptions = new _sbEventKit.CompositeDisposable();
    this.emitter = new _sbEventKit.Emitter();
    this.connections = new Set();
    this.server = null;
    this.queue = {};

    this.subscriptions.add(this.emitter);
  }

  Bridge.prototype.activate = function activate() {
    var _this = this;

    this.server = _ws.createServer({
      port: _libWport2['default']()
    }, function (connection) {
      _this.connections.add(connection);
      connection.on('close', function () {
        _this.connections['delete'](connection);
      });
      connection.on('message', function (data, flags) {
        if (flags.binary) {
          // Ignore binary
          _libFns.log.bridge('Ignoring message because its binary');
          return;
        }
        try {
          var message = JSON.parse(data);
          _libFns.log.bridge('IN', message._type);
          _this.emitter.emit('message:' + message._type, message);
        } catch (e) {
          _libFns.handleError(e);
        }
      });
      _this.welcomeConnection(connection);
    });
  };

  Bridge.prototype.welcomeConnection = function welcomeConnection(connection) {
    connection.send(this.encodeMessage('motion:baseDir', {
      dir: _cache2['default'].baseDir()
    }));
    connection.send(this.encodeMessage('motion:opts', _opts2['default']()));

    for (var key in this.queue) {
      connection.send(this.queue[key]);
    }
  };

  Bridge.prototype.broadcast = function broadcast(type, message) {
    var cacheKey = arguments.length <= 2 || arguments[2] === undefined ? null : arguments[2];

    this.broadcastRaw(this.encodeMessage(type, message), cacheKey);
  };

  Bridge.prototype.encodeMessage = function encodeMessage(type) {
    var message = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1];

    _libFns.log.bridge('OUT', type);
    return JSON.stringify(Object.assign({
      _type: type,
      timestamp: Date.now()
    }, message));
  };

  Bridge.prototype.broadcastRaw = function broadcastRaw(message) {
    var cacheKey = arguments.length <= 1 || arguments[1] === undefined ? null : arguments[1];

    if (typeof message !== 'string') {
      throw new Error('Malformed message given');
    }

    // If we have any active connections
    if (this.connections.size) {
      this.connections.forEach(function (connection) {
        connection.send(message);
      });
    }

    if (cacheKey !== null) {
      this.queue[cacheKey] = message;
    }
  };

  Bridge.prototype.onMessage = function onMessage(type, callback) {
    return this.emitter.on('message:' + type, callback);
  };

  Bridge.prototype.dispose = function dispose() {
    if (this.server) {
      this.server.close();
    }
    this.connections.clear();
    this.subscriptions.dispose();
    this.queue = null;
  };

  return Bridge;
})())();
module.exports = exports['default'];