sp-broadcaster/dist/sp-broadcaster.js

I'm the container that runs Streamplace broadcasts!

"use strict";

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

var _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; }();

var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

var _spClient = require("sp-client");

var _spClient2 = _interopRequireDefault(_spClient);

var _winston = require("winston");

var _winston2 = _interopRequireDefault(_winston);

var _stream = require("stream");

var _fileStreamer = require("./file-streamer");

var _fileStreamer2 = _interopRequireDefault(_fileStreamer);

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 getTableName = function getTableName(objName) {
  var definition = _spClient2.default.schema.definitions[objName];
  if (!definition) {
    throw new Error("I've never heard of an " + objName + ", can't watch it");
  }
  return definition.tableName;
};

var SPBroadcaster = function () {
  function SPBroadcaster(_ref) {
    var _this = this;

    var broadcastId = _ref.broadcastId,
        podIp = _ref.podIp;

    _classCallCheck(this, SPBroadcaster);

    this.podIp = podIp;
    this.mainStream = (0, _spClient.ptsNormalizerStream)();
    // this.mainStream.on("pts", ({ pts }) => {
    //   console.log(pts);
    // });
    this.mainStream.resume();
    _winston2.default.info("sp-broadcaster running for broadcast " + broadcastId);
    this.sourceHandles = {};
    this.sources = {};
    this.outputStreams = {};
    var broadcastHandle = _spClient2.default.broadcasts.watch({ id: broadcastId }).on("data", function (_ref2) {
      var _ref3 = _slicedToArray(_ref2, 1),
          broadcast = _ref3[0];

      _this.broadcast = broadcast;
      _this.watchSources();
    });
    var outputHandle = _spClient2.default.outputs.watch({ broadcastId: broadcastId }).on("newDoc", function (output) {
      var outputStream = (0, _spClient.rtmpOutputStream)({
        rtmpUrl: output.url
      });
      _this.outputStreams[output.id] = outputStream;
      _this.mainStream.pipe(outputStream);
    }).on("deletedDoc", function (id) {
      _this.mainStream.unpipe(_this.outputStreams[id]);
      _this.outputStreams[id].end();
      delete _this.outputStreams[id];
    });
    Promise.all([broadcastHandle, outputHandle]).then(function () {
      _this.reconcile();
    });
  }

  _createClass(SPBroadcaster, [{
    key: "watchSources",
    value: function watchSources() {
      var _this2 = this;

      var sourcesShouldWatch = this.broadcast.sources.map(function (_ref4) {
        var kind = _ref4.kind,
            id = _ref4.id;

        return kind + "/" + id;
      });
      var sourcesCurrentlyWatching = Object.keys(this.sourceHandles);
      var startWatching = sourcesShouldWatch.filter(function (s) {
        return !sourcesCurrentlyWatching.includes(s);
      });
      var stopWatching = sourcesCurrentlyWatching.filter(function (s) {
        return !sourcesShouldWatch.includes(s);
      });
      startWatching.forEach(function (s) {
        var _s$split = s.split("/"),
            _s$split2 = _slicedToArray(_s$split, 2),
            kind = _s$split2[0],
            id = _s$split2[1];

        var tableName = getTableName(kind);
        var handles = [];
        handles.push(_spClient2.default[tableName].watch({ id: id }).on("data", function (_ref5) {
          var _ref6 = _slicedToArray(_ref5, 1),
              source = _ref6[0];

          _this2.sources[id] = source;
        }), _spClient2.default.streams.watch({ source: { id: id } }).on("newDoc", function (stream) {
          _winston2.default.info("Boy howdy I should download some data from " + stream.url);
          var tcpIngress = (0, _spClient.tcpIngressStream)({ url: stream.url });
          tcpIngress.pipe(_this2.mainStream, { end: false });
        }));
        _this2.sourceHandles[s] = handles;
      });
      stopWatching.forEach(function (s) {
        var _s$split3 = s.split("/"),
            _s$split4 = _slicedToArray(_s$split3, 2),
            kind = _s$split4[0],
            id = _s$split4[1];

        _this2.sourceHandles[s].forEach(function (handle) {
          return handle.stop();
        });
        delete _this2.sourceHandles[s];
      });
    }
  }, {
    key: "reconcile",
    value: function reconcile() {
      _winston2.default.info("Broadcast " + this.broadcast.id + " updated");
    }
  }]);

  return SPBroadcaster;
}();

exports.default = SPBroadcaster;


if (!module.parent) {
  var BROADCAST_ID = _spClient.config.require("BROADCAST_ID");
  var POD_IP = _spClient.config.require("POD_IP");
  _spClient2.default.connect().then(function () {
    new SPBroadcaster({ broadcastId: BROADCAST_ID, podIp: POD_IP });
    // TODO: this should be a separate pod
    new _fileStreamer2.default({ broadcastId: BROADCAST_ID, podIp: POD_IP });
  }).catch(function (err) {
    _winston2.default.error(err);
    process.exit(1);
  });
}

process.on("SIGTERM", function () {
  process.exit(0);
});
//# sourceMappingURL=sp-broadcaster.js.map