motion/lib/runner/bridge.js

motion - moving development forward

'use strict';

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

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

var _ws = require('ws');

var _disposableEvent = require('disposable-event');

var _disposableEvent2 = _interopRequireDefault(_disposableEvent);

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 }; }

function _asyncToGenerator(fn) { return function () { var gen = fn.apply(this, arguments); return new Promise(function (resolve, reject) { function step(key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { return Promise.resolve(value).then(function (value) { return step("next", value); }, function (err) { return step("throw", err); }); } } return step("next"); }); }; }

class Bridge {

  constructor() {
    this.cache = new Map();
    this.server = null;
    this.emitter = new _sbEventKit.Emitter();
    this.connections = new Set();
    this.subscriptions = new _sbEventKit.CompositeDisposable();

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

  activate() {
    return new Promise((resolve, reject) => {
      const server = this.server = new _ws.Server({
        port: (0, _wport2.default)()
      });

      const subscriptions = new _sbEventKit.CompositeDisposable();
      subscriptions.add((0, _disposableEvent2.default)(server, 'listening', function () {
        subscriptions.dispose();
        resolve();
      }));

      subscriptions.add((0, _disposableEvent2.default)(server, 'error', function (error) {
        subscriptions.dispose();
        reject(error);
      }));

      this.subscriptions.add((0, _disposableEvent2.default)(server, 'connection', connection => this.handleConnection(connection)));
    });
  }
  handleConnection(connection) {
    this.connections.add(connection);

    connection.on('close', () => {
      this.connections.delete(connection);
    });

    connection.on('message', (() => {
      var _this2 = this;

      var ref = _asyncToGenerator(function* (data, flags) {
        if (flags.binary) {
          _fns.log.bridge('Ignoring message because it\'s binary');
          return;
        }

        let message;

        try {
          message = JSON.parse(data);
          _fns.log.bridge('IN', message._type);
          yield _this2.emitter.emit(`message:${ message._type }`, message);
        } catch (error) {
          (0, _fns.handleError)(error);
        } finally {
          if (message && message.id) {
            connection.send(_this2.encodeMessage(message._type, Object.assign({ id: message.id }, message.result)));
          }
        }
      }),
          _this = this;

      return function (_x, _x2) {
        return ref.apply(_this, arguments);
      };
    })());

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

    for (const value of this.cache.values()) {
      connection.send(value);
    }
  }

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

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

  encodeMessage(type, message) {
    _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) {
      this.cache.set(cacheKey, message);
    }
  }

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

  dispose() {
    if (this.server) {
      this.server.close();
    }
    this.connections.clear();
    this.subscriptions.dispose();
    this.cache.clear();
  }
}

exports.Bridge = Bridge;
exports.default = new Bridge();
//# sourceMappingURL=bridge.js.map