motion/lib/runner/bridge.js

motion - moving development forward

'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

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

var _ws = require('ws');

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

var _wport2 = _interopRequireDefault(_wport);

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

var _cache2 = _interopRequireDefault(_cache);

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

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

var _opts2 = _interopRequireDefault(_opts);

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

exports.default = new class Bridge {
  constructor() {
    this.subscriptions = new _sbEventKit.CompositeDisposable();
    this.emitter = new _sbEventKit.Emitter();
    this.connections = new Set();
    this.server = null;
    this.queue = {};

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

  activate() {
    this.server = (0, _ws.createServer)({
      port: (0, _wport2.default)()
    }, connection => {
      this.connections.add(connection);
      connection.on('close', () => {
        this.connections.delete(connection);
      });
      connection.on('message', (data, flags) => {
        if (flags.binary) {
          // Ignore binary
          _fns.log.bridge('Ignoring message because its binary');
          return;
        }
        try {
          const message = JSON.parse(data);
          _fns.log.bridge('IN', message._type);
          this.emitter.emit(`message:${ message._type }`, message);
        } catch (e) {
          (0, _fns.handleError)(e);
        }
      });
      this.welcomeConnection(connection);
    });
  }

  welcomeConnection(connection) {
    connection.send(this.encodeMessage('motion:baseDir', {
      dir: _cache2.default.baseDir()
    }));
    connection.send(this.encodeMessage('motion:opts', (0, _opts2.default)()));

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

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

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

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

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

  broadcastRaw(message) {
    let 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;
    }
  }

  onMessage(type, callback) {
    return this.emitter.on(`message:${ type }`, callback);
  }

  dispose() {
    if (this.server) {
      this.server.close();
    }
    this.connections.clear();
    this.subscriptions.dispose();
    this.queue = null;
  }
}();
//# sourceMappingURL=bridge.js.map