@eluvio/elv-client-js 4.0.56 → 4.0.58

package/dist/src/client/LiveStream.js

@@ -0,0 +1,1799 @@
+var _regeneratorRuntime = require("@babel/runtime/regenerator");
+var _asyncToGenerator = require("@babel/runtime/helpers/asyncToGenerator");
+/**
+ * Methods for Live Stream creation and management
+ *
+ * @module ElvClient/LiveStream
+ */
+
+var _require = require("./LiveConf"),
+  LiveConf = _require.LiveConf;
+var path = require("path");
+var fs = require("fs");
+var HttpClient = require("../HttpClient");
+//
+// const {
+//   ValidateLibrary,
+//   ValidateVersion,
+//   ValidateParameters
+// } = require("../Validation");
+
+var MakeTxLessToken = /*#__PURE__*/function () {
+  var _ref2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(_ref) {
+    var client, libraryId, objectId, versionHash, tok;
+    return _regeneratorRuntime.wrap(function _callee$(_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          client = _ref.client, libraryId = _ref.libraryId, objectId = _ref.objectId, versionHash = _ref.versionHash;
+          _context.next = 3;
+          return client.authClient.AuthorizationToken({
+            libraryId: libraryId,
+            objectId: objectId,
+            versionHash: versionHash,
+            channelAuth: false,
+            noCache: true,
+            noAuth: true
+          });
+        case 3:
+          tok = _context.sent;
+          return _context.abrupt("return", tok);
+        case 5:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee);
+  }));
+  return function MakeTxLessToken(_x) {
+    return _ref2.apply(this, arguments);
+  };
+}();
+function sleep(ms) {
+  return new Promise(function (resolve) {
+    return setTimeout(resolve, ms);
+  });
+}
+
+/**
+ * Retrieve the status of the current live stream session
+ *
+ * @methodGroup Live Stream
+ * @namedParams
+ * @param {string} name -
+ * @param {boolean} stopLro -
+ * @param {boolean} showParams -
+ * States:
+ * unconfigured    - no live_recording_config
+ * uninitialized   - no live_recording config generated
+ * inactive        - live_recording config initialized but no 'edge write token'
+ * stopped         - edge-write-token but not started
+ * starting        - LRO running but no source data yet
+ * running         - stream is running and producing output
+ * stalled         - LRO running but no source data (so not producing output)
+ *
+ * @return {Object} - The status response for the object, as well as logs, warnings and errors from the master initialization
+ */
+exports.StreamStatus = /*#__PURE__*/function () {
+  var _ref4 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2(_ref3) {
+    var name, _ref3$stopLro, stopLro, _ref3$showParams, showParams, conf, status, libraryId, mainMeta, fabURI, edgeWriteToken, edgeMeta, recordings, sequence, period, tlro, sinceLastFinalize, recording_period, insertions, i, insertionTimeSinceEpoch, state, lroStatus, playout_urls, objectId, playout_options, hls_clear_enabled, hls_aes128_enabled, hls_sample_aes_enabled, networkInfo, token, embed_net, embed_url;
+    return _regeneratorRuntime.wrap(function _callee2$(_context2) {
+      while (1) switch (_context2.prev = _context2.next) {
+        case 0:
+          name = _ref3.name, _ref3$stopLro = _ref3.stopLro, stopLro = _ref3$stopLro === void 0 ? false : _ref3$stopLro, _ref3$showParams = _ref3.showParams, showParams = _ref3$showParams === void 0 ? false : _ref3$showParams;
+          _context2.next = 3;
+          return this.LoadConf({
+            name: name
+          });
+        case 3:
+          conf = _context2.sent;
+          status = {
+            name: name
+          };
+          _context2.prev = 5;
+          _context2.next = 8;
+          return this.ContentObjectLibraryId({
+            objectId: conf.objectId
+          });
+        case 8:
+          libraryId = _context2.sent;
+          status.library_id = libraryId;
+          status.object_id = conf.objectId;
+          _context2.next = 13;
+          return this.ContentObjectMetadata({
+            libraryId: libraryId,
+            objectId: conf.objectId,
+            select: ["live_recording_config", "live_recording"]
+          });
+        case 13:
+          mainMeta = _context2.sent;
+          if (!(mainMeta.live_recording_config == undefined || mainMeta.live_recording_config.url == undefined)) {
+            _context2.next = 17;
+            break;
+          }
+          status.state = "unconfigured";
+          return _context2.abrupt("return", status);
+        case 17:
+          if (!(mainMeta.live_recording == undefined || mainMeta.live_recording.fabric_config == undefined || mainMeta.live_recording.playout_config == undefined || mainMeta.live_recording.recording_config == undefined)) {
+            _context2.next = 20;
+            break;
+          }
+          status.state = "uninitialized";
+          return _context2.abrupt("return", status);
+        case 20:
+          fabURI = mainMeta.live_recording.fabric_config.ingress_node_api;
+          if (!(fabURI === undefined)) {
+            _context2.next = 25;
+            break;
+          }
+          console.log("bad fabric config - missing ingress node API");
+          status.state = "uninitialized";
+          return _context2.abrupt("return", status);
+        case 25:
+          // Support both hostname and URL ingress_node_api
+          if (!fabURI.startsWith("http")) {
+            // Assume https
+            fabURI = "https://" + fabURI;
+          }
+          status.fabric_api = fabURI;
+          status.url = mainMeta.live_recording.recording_config.recording_params.origin_url;
+          edgeWriteToken = mainMeta.live_recording.fabric_config.edge_write_token;
+          if (!(edgeWriteToken == undefined)) {
+            _context2.next = 32;
+            break;
+          }
+          status.state = "inactive";
+          return _context2.abrupt("return", status);
+        case 32:
+          this.RecordWriteToken({
+            writeToken: edgeWriteToken,
+            fabricNodeUrl: fabURI
+          });
+          status.edge_write_token = edgeWriteToken;
+          status.stream_id = edgeWriteToken; // By convention the stream ID is its write token
+          _context2.next = 37;
+          return this.ContentObjectMetadata({
+            libraryId: libraryId,
+            objectId: conf.objectId,
+            writeToken: edgeWriteToken,
+            select: ["live_recording"]
+          });
+        case 37:
+          edgeMeta = _context2.sent;
+          if (!(edgeMeta.live_recording === undefined || edgeMeta.live_recording.recordings === undefined || edgeMeta.live_recording.recordings.recording_sequence === undefined)) {
+            _context2.next = 41;
+            break;
+          }
+          status.state = "stopped";
+          return _context2.abrupt("return", status);
+        case 41:
+          recordings = edgeMeta.live_recording.recordings;
+          status.recording_period_sequence = recordings.recording_sequence;
+          sequence = recordings.recording_sequence;
+          period = recordings.live_offering[sequence - 1];
+          tlro = period.live_recording_handle;
+          status.tlro = tlro;
+          sinceLastFinalize = Math.floor(new Date().getTime() / 1000) - period.video_finalized_parts_info.last_finalization_time / 1000000;
+          recording_period = {
+            activation_time_epoch_sec: period.recording_start_time_epoch_sec,
+            start_time_epoch_sec: period.start_time_epoch_sec,
+            start_time_text: new Date(period.start_time_epoch_sec * 1000).toLocaleString(),
+            end_time_epoch_sec: period.end_time_epoch_sec,
+            end_time_text: period.end_time_epoch_sec === 0 ? null : new Date(period.end_time_epoch_sec * 1000).toLocaleString(),
+            video_parts: period.video_finalized_parts_info.n_parts,
+            video_last_part_finalized_epoch_sec: period.video_finalized_parts_info.last_finalization_time / 1000000,
+            video_since_last_finalize_sec: sinceLastFinalize
+          };
+          status.recording_period = recording_period;
+          _context2.next = 52;
+          return this.FabricUrl({
+            libraryId: libraryId,
+            objectId: conf.objectId,
+            writeToken: edgeWriteToken,
+            call: "live/status/" + tlro
+          });
+        case 52:
+          status.lro_status_url = _context2.sent;
+          status.insertions = [];
+          if (edgeMeta.live_recording.playout_config.interleaves != undefined && edgeMeta.live_recording.playout_config.interleaves[sequence] != undefined) {
+            insertions = edgeMeta.live_recording.playout_config.interleaves[sequence];
+            for (i = 0; i < insertions.length; i++) {
+              insertionTimeSinceEpoch = recording_period.start_time_epoch_sec + insertions[i].insertion_time;
+              status.insertions[i] = {
+                insertion_time_since_start: insertions[i].insertion_time,
+                insertion_time: new Date(insertionTimeSinceEpoch * 1000).toISOString(),
+                insertion_time_local: new Date(insertionTimeSinceEpoch * 1000).toLocaleString(),
+                target: insertions[i].playout
+              };
+            }
+          }
+          if (showParams) {
+            status.recording_paramse = edgeMeta.live_recording.recording_config.recording_params;
+          }
+          state = "stopped";
+          lroStatus = "";
+          _context2.prev = 58;
+          _context2.t0 = this.utils;
+          _context2.next = 62;
+          return HttpClient.Fetch(status.lro_status_url);
+        case 62:
+          _context2.t1 = _context2.sent;
+          _context2.next = 65;
+          return _context2.t0.ResponseToJson.call(_context2.t0, _context2.t1);
+        case 65:
+          lroStatus = _context2.sent;
+          state = lroStatus.state;
+          _context2.next = 75;
+          break;
+        case 69:
+          _context2.prev = 69;
+          _context2.t2 = _context2["catch"](58);
+          console.log("LRO Status (failed): ", _context2.t2.response.statusCode);
+          status.state = "stopped";
+          status.error = _context2.t2.response;
+          return _context2.abrupt("return", status);
+        case 75:
+          // Convert LRO 'state' to desired 'state'
+          if (state === "running" && period.video_finalized_parts_info.last_finalization_time === 0) {
+            state = "starting";
+          } else if (state === "running" && sinceLastFinalize > 32.9) {
+            state = "stalled";
+          } else if (state == "terminated") {
+            state = "stopped";
+          }
+          status.state = state;
+          if (!((state === "running" || state === "stalled" || state === "starting") && stopLro)) {
+            _context2.next = 96;
+            break;
+          }
+          _context2.next = 80;
+          return this.FabricUrl({
+            libraryId: libraryId,
+            objectId: conf.objectId,
+            writeToken: edgeWriteToken,
+            call: "live/stop/" + tlro
+          });
+        case 80:
+          lroStopUrl = _context2.sent;
+          _context2.prev = 81;
+          _context2.t3 = this.utils;
+          _context2.next = 85;
+          return HttpClient.Fetch(lroStopUrl);
+        case 85:
+          _context2.t4 = _context2.sent;
+          _context2.next = 88;
+          return _context2.t3.ResponseToJson.call(_context2.t3, _context2.t4);
+        case 88:
+          console.log("LRO Stop: ", lroStatus.body);
+          _context2.next = 94;
+          break;
+        case 91:
+          _context2.prev = 91;
+          _context2.t5 = _context2["catch"](81);
+          console.log("LRO Stop (failed): ", _context2.t5.response.statusCode);
+        case 94:
+          state = "stopped";
+          status.state = state;
+        case 96:
+          if (!(state === "running")) {
+            _context2.next = 128;
+            break;
+          }
+          playout_urls = {};
+          objectId = conf.objectId;
+          _context2.next = 101;
+          return this.PlayoutOptions({
+            objectId: objectId,
+            linkPath: "public/asset_metadata/sources/default"
+          });
+        case 101:
+          playout_options = _context2.sent;
+          hls_clear_enabled = playout_options && playout_options.hls && playout_options.hls.playoutMethods && playout_options.hls.playoutMethods.clear !== undefined;
+          if (!hls_clear_enabled) {
+            _context2.next = 107;
+            break;
+          }
+          _context2.next = 106;
+          return this.FabricUrl({
+            libraryId: libraryId,
+            objectId: objectId,
+            rep: "playout/default/hls-clear/playlist.m3u8"
+          });
+        case 106:
+          playout_urls.hls_clear = _context2.sent;
+        case 107:
+          hls_aes128_enabled = playout_options && playout_options.hls && playout_options.hls.playoutMethods && playout_options.hls.playoutMethods["aes-128"] !== undefined;
+          if (!hls_aes128_enabled) {
+            _context2.next = 112;
+            break;
+          }
+          _context2.next = 111;
+          return this.FabricUrl({
+            libraryId: libraryId,
+            objectId: objectId,
+            rep: "playout/default/hls-aes128/playlist.m3u8"
+          });
+        case 111:
+          playout_urls.hls_aes128 = _context2.sent;
+        case 112:
+          hls_sample_aes_enabled = playout_options && playout_options.hls && playout_options.hls.playoutMethods && playout_options.hls.playoutMethods["sample-aes"] !== undefined;
+          if (!hls_sample_aes_enabled) {
+            _context2.next = 117;
+            break;
+          }
+          _context2.next = 116;
+          return this.FabricUrl({
+            libraryId: libraryId,
+            objectId: objectId,
+            rep: "playout/default/hls-sample-aes/playlist.m3u8"
+          });
+        case 116:
+          playout_urls.hls_sample_aes = _context2.sent;
+        case 117:
+          _context2.next = 119;
+          return this.NetworkInfo();
+        case 119:
+          networkInfo = _context2.sent;
+          _context2.next = 122;
+          return this.authClient.AuthorizationToken({
+            libraryId: libraryId,
+            objectId: objectId,
+            channelAuth: false,
+            noCache: true,
+            noAuth: true
+          });
+        case 122:
+          token = _context2.sent;
+          embed_net = "main";
+          if (networkInfo.name.includes("demo")) {
+            embed_net = "demo";
+          }
+          embed_url = "https://embed.v3.contentfabric.io/?net=".concat(embed_net, "&p&ct=h&oid=").concat(conf.objectId, "&mt=lv&ath=").concat(token);
+          playout_urls.embed_url = embed_url;
+          status.playout_urls = playout_urls;
+        case 128:
+          _context2.next = 133;
+          break;
+        case 130:
+          _context2.prev = 130;
+          _context2.t6 = _context2["catch"](5);
+          console.error(_context2.t6);
+        case 133:
+          return _context2.abrupt("return", status);
+        case 134:
+        case "end":
+          return _context2.stop();
+      }
+    }, _callee2, this, [[5, 130], [58, 69], [81, 91]]);
+  }));
+  return function (_x2) {
+    return _ref4.apply(this, arguments);
+  };
+}();
+
+// async StatusPrep({name}) {
+//
+//   let conf = await this.LoadConf({name});
+//
+//   try {
+//
+//     // Set static token - avoid individual auth for separate channels/streams
+//     let token = await MakeTxLessToken({client: this.client, libraryId: conf.libraryId});
+//     this.client.SetStaticToken({token});
+//
+//   } catch(error) {
+//     console.log("StatusPrep failed: ", error);
+//     return null;
+//   }
+//
+// }
+
+/**
+ * Create a new edge write token
+ *
+ * @methodGroup Live Stream
+ * @namedParams
+ * @param {string} name -
+ * @param {boolean} start -
+ *
+ * @return {Object} - The status response for the object
+ *
+*/
+exports.StreamCreate = /*#__PURE__*/function () {
+  var _ref6 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee3(_ref5) {
+    var name, _ref5$start, start, status, objectId, libraryId, liveRecording, fabURI, response, edgeToken, writeToken, objectHash;
+    return _regeneratorRuntime.wrap(function _callee3$(_context3) {
+      while (1) switch (_context3.prev = _context3.next) {
+        case 0:
+          name = _ref5.name, _ref5$start = _ref5.start, start = _ref5$start === void 0 ? false : _ref5$start;
+          _context3.next = 3;
+          return this.StreamStatus({
+            name: name
+          });
+        case 3:
+          status = _context3.sent;
+          if (!(status.state !== "inactive" && status.state !== "terminated" && status.state !== "stopped")) {
+            _context3.next = 6;
+            break;
+          }
+          return _context3.abrupt("return", {
+            state: status.state,
+            error: "stream still active - must terminate first"
+          });
+        case 6:
+          objectId = status.object_id;
+          console.log("START: ", name, "start", start);
+          _context3.next = 10;
+          return this.ContentObjectLibraryId({
+            objectId: objectId
+          });
+        case 10:
+          libraryId = _context3.sent;
+          _context3.next = 13;
+          return this.ContentObjectMetadata({
+            libraryId: libraryId,
+            objectId: objectId,
+            metadataSubtree: "/live_recording"
+          });
+        case 13:
+          liveRecording = _context3.sent;
+          fabURI = liveRecording.fabric_config.ingress_node_api; // Support both hostname and URL ingress_node_api
+          if (!fabURI.startsWith("http")) {
+            // Assume https
+            fabURI = "https://" + fabURI;
+          }
+          this.SetNodes({
+            fabricURIs: [fabURI]
+          });
+          console.log("Node URI", fabURI, "ID", liveRecording.fabric_config.ingress_node_id);
+          _context3.next = 20;
+          return this.EditContentObject({
+            libraryId: libraryId,
+            objectId: objectId
+          });
+        case 20:
+          response = _context3.sent;
+          edgeToken = response.write_token;
+          console.log("Edge token:", edgeToken);
+
+          /*
+          * Set the metadata, including the edge token.
+          */
+          _context3.next = 25;
+          return this.EditContentObject({
+            libraryId: libraryId,
+            objectId: objectId
+          });
+        case 25:
+          response = _context3.sent;
+          writeToken = response.write_token;
+          this.Log("Merging metadata: ", libraryId, objectId, writeToken);
+          _context3.next = 30;
+          return this.MergeMetadata({
+            libraryId: libraryId,
+            objectId: objectId,
+            writeToken: writeToken,
+            metadata: {
+              live_recording: {
+                status: {
+                  edge_write_token: edgeToken,
+                  state: "active" // indicates there is an active session (set to 'closed' when done)
+                },
+
+                fabric_config: {
+                  edge_write_token: edgeToken
+                }
+              }
+            }
+          });
+        case 30:
+          this.Log("Finalizing content draft: ", libraryId, objectId, writeToken);
+          _context3.next = 33;
+          return this.FinalizeContentObject({
+            libraryId: libraryId,
+            objectId: objectId,
+            writeToken: writeToken,
+            commitMessage: "Create stream edge write token " + edgeToken
+          });
+        case 33:
+          response = _context3.sent;
+          objectHash = response.hash;
+          this.Log("Finalized object: ", objectHash);
+          status = {
+            object_id: objectId,
+            hash: objectHash,
+            library_id: libraryId,
+            stream_id: edgeToken,
+            edge_write_token: edgeToken,
+            fabric_api: fabURI,
+            state: "stopped"
+          };
+          if (start) {
+            status = this.StreamStartOrStopOrReset({
+              name: name,
+              op: start
+            });
+          }
+          return _context3.abrupt("return", status);
+        case 39:
+        case "end":
+          return _context3.stop();
+      }
+    }, _callee3, this);
+  }));
+  return function (_x3) {
+    return _ref6.apply(this, arguments);
+  };
+}();
+
+/**
+ * Start, stop or reset a stream within the current session (current edge write token)
+ *
+ * @methodGroup Live Stream
+ * @namedParams
+ * @param {string} name -
+ * @param {string=} op - The operation to perform. Possible values:
+ * 'start'
+ * 'reset' - Stops current LRO recording and starts a new one.  Does
+ * not create a new edge write token (just creates a new recording
+ * period in the existing edge write token)
+ * - 'stop'
+ *
+ * @return {Object} - The status response for the stream
+ *
+*/
+exports.StreamStartOrStopOrReset = /*#__PURE__*/function () {
+  var _ref8 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee4(_ref7) {
+    var name, op, status, _tries, tries;
+    return _regeneratorRuntime.wrap(function _callee4$(_context4) {
+      while (1) switch (_context4.prev = _context4.next) {
+        case 0:
+          name = _ref7.name, op = _ref7.op;
+          _context4.prev = 1;
+          console.log("Stream ", op, ": ", name);
+          _context4.next = 5;
+          return this.StreamStatus({
+            name: name
+          });
+        case 5:
+          status = _context4.sent;
+          if (!(status.state != "stopped")) {
+            _context4.next = 10;
+            break;
+          }
+          if (!(op === "start")) {
+            _context4.next = 10;
+            break;
+          }
+          status.error = "Unable to start stream - state: " + status.state;
+          return _context4.abrupt("return", status);
+        case 10:
+          if (!(status.state == "running" || status.state == "starting" || status.state == "stalled")) {
+            _context4.next = 33;
+            break;
+          }
+          console.log("STOPPING");
+          _context4.prev = 12;
+          _context4.next = 15;
+          return this.CallBitcodeMethod({
+            libraryId: status.library_id,
+            objectId: status.object_id,
+            writeToken: status.edge_write_token,
+            method: "/live/stop/" + status.tlro,
+            constant: false
+          });
+        case 15:
+          _context4.next = 19;
+          break;
+        case 17:
+          _context4.prev = 17;
+          _context4.t0 = _context4["catch"](12);
+        case 19:
+          // Wait until LRO is terminated
+          _tries = 10;
+        case 20:
+          if (!(status.state != "stopped" && _tries-- > 0)) {
+            _context4.next = 29;
+            break;
+          }
+          console.log("Wait to terminate - ", status.state);
+          _context4.next = 24;
+          return sleep(1000);
+        case 24:
+          _context4.next = 26;
+          return this.StreamStatus({
+            name: name
+          });
+        case 26:
+          status = _context4.sent;
+          _context4.next = 20;
+          break;
+        case 29:
+          console.log("Status after terminate - ", status.state);
+          if (!(_tries <= 0)) {
+            _context4.next = 33;
+            break;
+          }
+          console.log("Failed to terminate");
+          return _context4.abrupt("return", status);
+        case 33:
+          if (!(op === "stop")) {
+            _context4.next = 35;
+            break;
+          }
+          return _context4.abrupt("return", status);
+        case 35:
+          console.log("STARTING", "edge_write_token", status.edge_write_token);
+          _context4.prev = 36;
+          _context4.next = 39;
+          return this.CallBitcodeMethod({
+            libraryId: status.library_id,
+            objectId: status.object_id,
+            writeToken: status.edge_write_token,
+            method: "/live/start",
+            constant: false
+          });
+        case 39:
+          _context4.next = 45;
+          break;
+        case 41:
+          _context4.prev = 41;
+          _context4.t1 = _context4["catch"](36);
+          console.log("LRO Start (failed): ", _context4.t1);
+          return _context4.abrupt("return", {
+            state: status.state,
+            error: "LRO start failed - must create a stream first"
+          });
+        case 45:
+          // Wait until LRO is 'starting'
+          tries = 10;
+        case 46:
+          if (!(status.state != "starting" && tries-- > 0)) {
+            _context4.next = 55;
+            break;
+          }
+          console.log("Wait to start - ", status.state);
+          _context4.next = 50;
+          return sleep(1000);
+        case 50:
+          _context4.next = 52;
+          return this.StreamStatus({
+            name: name
+          });
+        case 52:
+          status = _context4.sent;
+          _context4.next = 46;
+          break;
+        case 55:
+          console.log("Status after restart - ", status.state);
+          return _context4.abrupt("return", status);
+        case 59:
+          _context4.prev = 59;
+          _context4.t2 = _context4["catch"](1);
+          console.error(_context4.t2);
+        case 62:
+        case "end":
+          return _context4.stop();
+      }
+    }, _callee4, this, [[1, 59], [12, 17], [36, 41]]);
+  }));
+  return function (_x4) {
+    return _ref8.apply(this, arguments);
+  };
+}();
+
+/*
+ * Stop the live stream session and close the edge write token.
+ * Not implemented fully
+ */
+// async StopSession({name}) {
+//
+//   try {
+//
+//     console.log("TERMINATE: ", name);
+//
+//     let conf = await this.LoadConf({name});
+//
+//     let objectId = conf.objectId;
+//     let libraryId = await this.client.ContentObjectLibraryId({objectId: objectId});
+//
+//     let mainMeta = await this.client.ContentObjectMetadata({
+//       libraryId: libraryId,
+//       objectId: objectId
+//     });
+//
+//     let fabURI = mainMeta.live_recording.fabric_config.ingress_node_api;
+//     // Support both hostname and URL ingress_node_api
+//     if(!fabURI.startsWith("http")) {
+//       // Assume https
+//       fabURI = "https://" + fabURI;
+//     }
+//
+//     this.client.SetNodes({fabricURIs: [fabURI]});
+//
+//     let edgeWriteToken = mainMeta.live_recording.fabric_config.edge_write_token;
+//
+//     if(edgeWriteToken === undefined || edgeWriteToken === "") {
+//       return {
+//         state: "inactive",
+//         error: "no active streams - must create a stream first"
+//       };
+//     }
+//     let edgeMeta = await this.client.ContentObjectMetadata({
+//       libraryId: libraryId,
+//       objectId: objectId,
+//       writeToken: edgeWriteToken
+//     });
+//
+//     // Stop the LRO if running
+//     let status = await this.Status({name});
+//     if(status.state != "terminated") {
+//       console.log("STOPPING");
+//       try {
+//         await this.client.CallBitcodeMethod({
+//           libraryId: status.library_id,
+//           objectId: status.object_id,
+//           writeToken: status.edge_write_token,
+//           method: "/live/stop/" + status.tlro,
+//           constant: false
+//         });
+//       } catch(error) {
+//         // The /call/lro/stop API returns empty response
+//         // console.log("LRO Stop (failed): ", error);
+//       }
+//
+//       // Wait until LRO is terminated
+//       let tries = 10;
+//       while (status.state != "terminated" && tries-- > 0) {
+//         console.log("Wait to terminate - ", status.state);
+//         await sleep(1000);
+//         status = await this.Status({name});
+//       }
+//       console.log("Status after terminate - ", status.state);
+//
+//       if(tries <= 0) {
+//         console.log("Failed to terminate");
+//         return status;
+//       }
+//     }
+//
+//     // Set stop time
+//     edgeMeta.recording_stop_time = Math.floor(new Date().getTime() / 1000);
+//     console.log("recording_start_time: ", edgeMeta.recording_start_time);
+//     console.log("recording_stop_time:  ", edgeMeta.recording_stop_time);
+//
+//     edgeMeta.live_recording.status = {
+//       state: "terminated",
+//       recording_stop_time: edgeMeta.recording_stop_time
+//     };
+//
+//     edgeMeta.live_recording.fabric_config.edge_write_token = "";
+//
+//     await this.client.ReplaceMetadata({
+//       libraryId: libraryId,
+//       objectId: objectId,
+//       writeToken: edgeWriteToken,
+//       metadata: edgeMeta
+//     });
+//
+//     let fin = await this.client.FinalizeContentObject({
+//       libraryId,
+//       objectId,
+//       writeToken: edgeWriteToken,
+//       commitMessage: "Finalize live stream - stop time " + edgeMeta.recording_stop_time,
+//       publish: false // Don't publish this version because it is not currently useful
+//     });
+//
+//     return {
+//       fin,
+//       name: name,
+//       edge_write_token: edgeWriteToken,
+//       state: "terminated"
+//     };
+//
+//   } catch(error) {
+//     console.error(error);
+//   }
+// }
+
+// async Initialize({name, drm=false, format}) {
+//
+//   const contentTypes = await this.client.ContentTypes();
+//
+//   let typeAbrMaster;
+//   let typeLiveStream;
+//   for (let i = 0; i < Object.keys(contentTypes).length; i ++) {
+//     const key = Object.keys(contentTypes)[i];
+//     if(contentTypes[key].name.includes("ABR Master") || contentTypes[key].name.includes("Title")) {
+//       typeAbrMaster = contentTypes[key].hash;
+//     }
+//     if(contentTypes[key].name.includes("Live Stream")) {
+//       typeLiveStream = contentTypes[key].hash;
+//     }
+//   }
+//
+//   if(typeAbrMaster === undefined || typeLiveStream === undefined) {
+//     console.log("ERROR - unable to find content types", "ABR Master", typeAbrMaster, "Live Stream", typeLiveStream);
+//     return {};
+//   }
+//   let res = await this.SetOfferingAndDRM({name, typeAbrMaster, typeLiveStream, drm, format});
+//   return res;
+// }
+
+// async SetOfferingAndDRM({name, typeAbrMaster, typeLiveStream, drm=false, format}) {
+//
+//   let status = await this.Status({name});
+//   if(status.state != "inactive" && status.state != "terminated") {
+//     return {
+//       state: status.state,
+//       error: "stream still active - must terminate first"
+//     };
+//   }
+//
+//   let objectId = status.object_id;
+//
+//   console.log("INIT: ", name, objectId);
+//
+//   const {GenerateOffering} = require("./LiveObjectSetupStepOne");
+//
+//   const aBitRate = 128000;
+//   const aChannels = 2;
+//   const aSampleRate = 48000;
+//   const aStreamIndex = 1;
+//   const aTimeBase = "1/48000";
+//   const aChannelLayout = "stereo";
+//
+//   const vBitRate = 14000000;
+//   const vHeight = 720;
+//   const vStreamIndex = 0;
+//   const vWidth = 1280;
+//   const vDisplayAspectRatio = "16/9";
+//   const vFrameRate = "30000/1001";
+//   const vTimeBase = "1/30000"; // "1/16000";
+//
+//   const abrProfile = require("./abr_profile_live_drm.json");
+//
+//   let playoutFormats = abrProfile.playout_formats;
+//   if(format) {
+//     drm = true; // Override DRM parameter
+//     playoutFormats = {};
+//     let formats = format.split(",");
+//     for (let i = 0; i < formats.length; i++) {
+//       if(formats[i] === "hls-clear") {
+//         abrProfile.drm_optional = true;
+//         playoutFormats["hls-clear"] = {
+//           "drm": null,
+//           "protocol": {
+//             "type": "ProtoHls"
+//           }
+//         };
+//         continue;
+//       }
+//       playoutFormats[formats[i]] = abrProfile.playout_formats[formats[i]];
+//     }
+//   } else if(!drm) {
+//     abrProfile.drm_optional = true;
+//     playoutFormats = {
+//       "hls-clear": {
+//         "drm": null,
+//         "protocol": {
+//           "type": "ProtoHls"
+//         }
+//       }
+//     };
+//   }
+//
+//   abrProfile.playout_formats = playoutFormats;
+//
+//   let libraryId = await this.client.ContentObjectLibraryId({objectId});
+//
+//   try {
+//
+//     let mainMeta = await this.client.ContentObjectMetadata({
+//       libraryId: libraryId,
+//       objectId: objectId
+//     });
+//
+//     let fabURI = mainMeta.live_recording.fabric_config.ingress_node_api;
+//     // Support both hostname and URL ingress_node_api
+//     if(!fabURI.startsWith("http")) {
+//       // Assume https
+//       fabURI = "https://" + fabURI;
+//     }
+//
+//     this.client.SetNodes({fabricURIs: [fabURI]});
+//
+//     let streamUrl = mainMeta.live_recording.recording_config.recording_params.origin_url;
+//
+//     await GenerateOffering({
+//       client: this.client,
+//       libraryId,
+//       objectId,
+//       typeAbrMaster, typeLiveStream,
+//       streamUrl,
+//       abrProfile,
+//       aBitRate, aChannels, aSampleRate, aStreamIndex,
+//       aTimeBase,
+//       aChannelLayout,
+//       vBitRate, vHeight, vStreamIndex, vWidth,
+//       vDisplayAspectRatio, vFrameRate, vTimeBase
+//     });
+//
+//     console.log("GenerateOffering - DONE");
+//
+//     return {
+//       name,
+//       object_id: objectId,
+//       state: "initialized"
+//     };
+//   } catch(error) {
+//     console.error(error);
+//   }
+// }
+
+// Add a content insertion entry
+// Parameters:
+// - insertionTime - seconds (float)
+// - sinceStart - true if time specified since stream start, false if since epoch
+// - duration - seconds (float, deafault 20.0)
+// - targetHash -  playable
+// - remove - flag to remove the insertion at that exact 'time' (instead of adding)
+// async Insertion({name, insertionTime, sinceStart, duration, targetHash, remove}) {
+//
+//   // Determine audio and video parameters of the insertion
+//   const insertionInfo = await this.getOfferingInfo({versionHash: targetHash});
+//   const audioAbrDuration = insertionInfo.audio.seg_duration_sec;
+//   const videoAbrDuration = insertionInfo.video.seg_duration_sec;
+//
+//   if(audioAbrDuration === 0 || videoAbrDuration === 0) {
+//     throw new Error("Bad segment duration hash:", targetHash);
+//   }
+//
+//   if(duration === undefined) {
+//     duration = insertionInfo.duration_sec;  // Use full duration of the insertion
+//   } else {
+//     if(duration > insertionInfo.duration_sec) {
+//       throw new Error("Bad duration - larger than insertion object duration", insertionInfo.duration_sec);
+//     }
+//   }
+//
+//   let conf = await this.LoadConf({name});
+//   let libraryId = await this.client.ContentObjectLibraryId({objectId: conf.objectId});
+//   let objectId = conf.objectId;
+//
+//   let mainMeta = await this.client.ContentObjectMetadata({
+//     libraryId: libraryId,
+//     objectId: conf.objectId
+//   });
+//
+//   let fabURI = mainMeta.live_recording.fabric_config.ingress_node_api;
+//
+//   // Support both hostname and URL ingress_node_api
+//   if(!fabURI.startsWith("http")) {
+//     // Assume https
+//     fabURI = "https://" + fabURI;
+//   }
+//   this.client.SetNodes({fabricURIs: [fabURI]});
+//   let edgeWriteToken = mainMeta.live_recording.fabric_config.edge_write_token;
+//
+//   let edgeMeta = await this.client.ContentObjectMetadata({
+//     libraryId: libraryId,
+//     objectId: conf.objectId,
+//     writeToken: edgeWriteToken
+//   });
+//
+//   // Find stream start time (from the most recent recording section)
+//   let recordings = edgeMeta.live_recording.recordings;
+//   let sequence = 1;
+//   let streamStartTime = 0;
+//   if(recordings != undefined && recordings.recording_sequence != undefined) {
+//     // We have at least one recording - check if still active
+//     sequence = recordings.recording_sequence;
+//     let period = recordings.live_offering[sequence - 1];
+//
+//     if(period.end_time_epoch_sec > 0) {
+//       // The last period is closed - apply insertions to the next period
+//       sequence ++;
+//     } else {
+//       // The period is active
+//       streamStartTime = period.start_time_epoch_sec;
+//     }
+//   }
+//
+//   if(streamStartTime === 0) {
+//     // There is no active period - must use absolute time
+//     if(sinceStart === false) {
+//       throw new Error("Stream not running - must use 'time since start'");
+//     }
+//   }
+//
+//   // Find the current period playout configuration
+//   if(edgeMeta.live_recording.playout_config.interleaves === undefined) {
+//     edgeMeta.live_recording.playout_config.interleaves = {};
+//   }
+//   if(edgeMeta.live_recording.playout_config.interleaves[sequence] === undefined) {
+//     edgeMeta.live_recording.playout_config.interleaves[sequence] = [];
+//   }
+//
+//   let playoutConfig = edgeMeta.live_recording.playout_config;
+//   let insertions = playoutConfig.interleaves[sequence];
+//
+//   let res = {};
+//
+//   if(!sinceStart) {
+//     insertionTime = insertionTime - streamStartTime;
+//   }
+//
+//   // Assume insertions are sorted by insertion time
+//   let errs = [];
+//   let currentTime = -1;
+//   let insertionDone = false;
+//   let newInsertion = {
+//     insertion_time: insertionTime,
+//     duration: duration,
+//     audio_abr_duration: audioAbrDuration,
+//     video_abr_duration: videoAbrDuration,
+//     playout: "/qfab/" + targetHash + "/rep/playout"  // TO FIX - should be a link
+//   };
+//
+//   for (let i = 0; i < insertions.length; i ++) {
+//     if(insertions[i].insertion_time <= currentTime) {
+//       // Bad insertion - must be later than current time
+//       append(errs, "Bad insertion - time:", insertions[i].insertion_time);
+//     }
+//     if(remove) {
+//       if(insertions[i].insertion_time === insertionTime) {
+//         insertions.splice(i, 1);
+//         break;
+//       }
+//     } else {
+//       if(insertions[i].insertion_time > insertionTime) {
+//         if(i > 0) {
+//           insertions = [
+//             ...insertions.splice(0, i),
+//             newInsertion,
+//             ...insertions.splice(i)
+//           ];
+//         } else {
+//           insertions = [
+//             newInsertion,
+//             ...insertions.splice(i)
+//           ];
+//         }
+//         insertionDone = true;
+//         break;
+//       }
+//     }
+//   }
+//
+//   if(!remove && !insertionDone) {
+//     // Add to the end of the insertions list
+//     console.log("Add insertion at the end");
+//     insertions = [
+//       ...insertions,
+//       newInsertion
+//     ];
+//   }
+//
+//   playoutConfig.interleaves[sequence] = insertions;
+//
+//   // Store the new insertions in the write token
+//   await this.client.ReplaceMetadata({
+//     libraryId: libraryId,
+//     objectId: objectId,
+//     writeToken: edgeWriteToken,
+//     metadataSubtree: "/live_recording/playout_config",
+//     metadata: edgeMeta.live_recording.playout_config
+//   });
+//
+//   res.errors = errs;
+//   res.insertions = insertions;
+//   return res;
+// }
+
+exports.LoadConf = /*#__PURE__*/function () {
+  var _ref10 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee5(_ref9) {
+    var name, streamsBuf, streams, conf;
+    return _regeneratorRuntime.wrap(function _callee5$(_context5) {
+      while (1) switch (_context5.prev = _context5.next) {
+        case 0:
+          name = _ref9.name;
+          if (!name.startsWith("iq__")) {
+            _context5.next = 3;
+            break;
+          }
+          return _context5.abrupt("return", {
+            name: name,
+            objectId: name
+          });
+        case 3:
+          _context5.prev = 3;
+          streamsBuf = fs.readFileSync(path.resolve(__dirname, "../liveconf.json"));
+          _context5.next = 11;
+          break;
+        case 7:
+          _context5.prev = 7;
+          _context5.t0 = _context5["catch"](3);
+          console.log("Stream name must be a QID or a label in liveconf.json");
+          return _context5.abrupt("return", {});
+        case 11:
+          streams = JSON.parse(streamsBuf);
+          conf = streams[name];
+          if (!(conf === null)) {
+            _context5.next = 16;
+            break;
+          }
+          console.log("Bad name: ", name);
+          return _context5.abrupt("return", {});
+        case 16:
+          return _context5.abrupt("return", conf);
+        case 17:
+        case "end":
+          return _context5.stop();
+      }
+    }, _callee5, null, [[3, 7]]);
+  }));
+  return function (_x5) {
+    return _ref10.apply(this, arguments);
+  };
+}();
+
+/*
+ * Read a playable contnet object and get information about a particular offering
+ */
+// async getOfferingInfo({versionHash, offering = "default"}) {
+//
+//   // Content Type check is currently disabled due to permissions
+//   /*
+//   let ct = await this.client.ContentObject({versionHash});
+//   if(ct.type != undefined && ct.type != "") {
+//     let typeMeta = await this.client.ContentObjectMetadata({
+//       versionHash: ct.type
+//     });
+//     if(typeMeta.bitcode_flags != "abrmaster") {
+//       throw new Error("Not a playable VoD object " + versionHash);
+//     }
+//   }
+//   */
+//   let offeringMeta = await this.client.ContentObjectMetadata({
+//     versionHash,
+//     metadataSubtree: "/offerings/" + offering
+//   });
+//
+//   var info = {
+//     duration_sec: 0 // Minimum of video and audio duration
+//   };
+//   ["video", "audio"].forEach(mt =>  {
+//     const stream = offeringMeta.media_struct.streams[mt];
+//     info[mt] = {
+//       seg_duration_sec: stream.optimum_seg_dur.float,
+//       duration_sec: stream.duration.float,
+//       frame_rate_rat: stream.rate,
+//     };
+//     if(info.duration_sec === 0 || stream.duration.float < info.duration_sec) {
+//       info.duration_sec = stream.duration.float;
+//     }
+//   });
+//   return info;
+// }
+
+// async StreamDownload({name, period}) {
+//
+//   let conf = await this.LoadConf({name});
+//
+//   let status = {name};
+//
+//   try {
+//
+//     let libraryId = await this.client.ContentObjectLibraryId({objectId: conf.objectId});
+//     status.library_id = libraryId;
+//     status.object_id = conf.objectId;
+//
+//     let mainMeta = await this.client.ContentObjectMetadata({
+//       libraryId: libraryId,
+//       objectId: conf.objectId
+//     });
+//
+//     let fabURI = mainMeta.live_recording.fabric_config.ingress_node_api;
+//     if(fabURI === undefined) {
+//       console.log("bad fabric config - missing ingress node API");
+//     }
+//
+//     // Support both hostname and URL ingress_node_api
+//     if(!fabURI.startsWith("http")) {
+//       // Assume https
+//       fabURI = "https://" + fabURI;
+//     }
+//     this.client.SetNodes({fabricURIs: [fabURI]});
+//
+//     let edgeWriteToken = mainMeta.live_recording.fabric_config.edge_write_token;
+//     let edgeMeta = await this.client.ContentObjectMetadata({
+//       libraryId: libraryId,
+//       objectId: conf.objectId,
+//       writeToken: edgeWriteToken
+//     });
+//
+//     // If a stream has never been started return state 'inactive'
+//     if(edgeMeta.live_recording === undefined ||
+//       edgeMeta.live_recording.recordings === undefined ||
+//       edgeMeta.live_recording.recordings.recording_sequence === undefined) {
+//       status.state = "no recordings";
+//       return status;
+//     }
+//
+//     let recordings = edgeMeta.live_recording.recordings;
+//     status.recording_period_sequence = recordings.recording_sequence;
+//
+//     let sequence = recordings.recording_sequence;
+//     if(period === undefined || period < 0 || period > sequence - 1) {
+//       period = sequence - 1;
+//     }
+//
+//     console.log("Downloading stream", name, " period", period, " latest", sequence - 1);
+//
+//     let recording = recordings.live_offering[period];
+//     if(recording === undefined) {
+//       console.log("ERROR - recording period not found: ", period);
+//     }
+//
+//     let dpath = "DOWNLOAD/" + edgeWriteToken + "." + period;
+//     !fs.existsSync(dpath) && fs.mkdirSync(dpath, {recursive: true});
+//
+//     let mts = ["audio", "video"];
+//     for (let mi = 0; mi < mts.length; mi ++) {
+//       let mt = mts[mi];
+//       console.log("Downloading ", mt);
+//       let mtpath = dpath + "/" + mt;
+//       let partsfile = dpath + "/parts_" + mt + ".txt";
+//       !fs.existsSync(mtpath) && fs.mkdirSync(mtpath);
+//       var sources = recording.sources[mt];
+//       for (let i = 0; i < sources.length - 1; i++) {
+//         console.log(sources[i].hash);
+//         let partHash = sources[i].hash;
+//         let buf = await this.client.DownloadPart({
+//           libraryId,
+//           objectId: conf.objectId,
+//           partHash,
+//           format: "buffer",
+//           chunked: false,
+//           callback: ({bytesFinished, bytesTotal}) => {
+//             console.log("  progress: ", bytesFinished + "/" + bytesTotal);
+//           }
+//         });
+//
+//         let partfile = mtpath + "/" + partHash + ".mp4";
+//         fs.appendFile(partfile, buf, (err) => {
+//           if(err)
+//             console.log(err);
+//         });
+//         fs.appendFile(partsfile, "file '" + mt + "/" + partHash + ".mp4'\n", (err) => {
+//           if(err)
+//             console.log(err);
+//         });
+//       }
+//
+//       // Concatenate parts into one mp4
+//       let cmd = "ffmpeg -f concat -safe 0 -i " + partsfile + " -c copy " + dpath + "/" + mt + ".mp4";
+//       console.log("Running", cmd);
+//       execSync(cmd);
+//     }
+//
+//     // Create final mp4 file
+//     let f = dpath + "/download.mp4";
+//     let cmd = "ffmpeg -i " + dpath + "/video.mp4"  + "  -i " +  dpath + "/audio.mp4" + "  -map 0:v:0  -map 1:a:0  -c copy  -shortest " + f;
+//     console.log("Running", cmd);
+//     execSync(cmd);
+//
+//     status.file = f;
+//     status.state = "completed";
+//   } catch(e) {
+//     console.log("Download failed", e);
+//     throw e;
+//   }
+//
+//   return status;
+// }
+
+/**
+ * Configure the stream
+ *
+ * @methodGroup Live Stream
+ * @namedParams
+ * @param {string} name -
+ * @param {string=} op - The operation to perform. Possible values:
+ * 'start'
+ * 'reset' - Stops current LRO recording and starts a new one.  Does
+ * not create a new edge write token (just creates a new recording
+ * period in the existing edge write token)
+ * - 'stop'
+ *
+ * @return {Object} - The status response for the stream
+ *
+ */
+exports.StreamConfig = /*#__PURE__*/function () {
+  var _ref12 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee6(_ref11) {
+    var name, customSettings, conf, status, libraryId, mainMeta, userConfig, hostName, streamUrl, nodes, node, endpoint, probe, controller, timeoutId, probeUrl, lc, liveRecordingConfigStr, liveRecordingConfig, e, writeToken;
+    return _regeneratorRuntime.wrap(function _callee6$(_context6) {
+      while (1) switch (_context6.prev = _context6.next) {
+        case 0:
+          name = _ref11.name, customSettings = _ref11.customSettings;
+          _context6.next = 3;
+          return this.LoadConf({
+            name: name
+          });
+        case 3:
+          conf = _context6.sent;
+          status = {
+            name: name
+          };
+          _context6.next = 7;
+          return this.ContentObjectLibraryId({
+            objectId: conf.objectId
+          });
+        case 7:
+          libraryId = _context6.sent;
+          status.library_id = libraryId;
+          status.object_id = conf.objectId;
+          _context6.next = 12;
+          return this.ContentObjectMetadata({
+            libraryId: libraryId,
+            objectId: conf.objectId
+          });
+        case 12:
+          mainMeta = _context6.sent;
+          userConfig = mainMeta.live_recording_config;
+          status.user_config = userConfig;
+
+          // Get node URI from user config
+          hostName = userConfig.url.replace("udp://", "").replace("rtmp://", "").split(":")[0];
+          streamUrl = new URL(userConfig.url);
+          console.log("Retrieving nodes...");
+          _context6.next = 20;
+          return this.SpaceNodes({
+            matchEndpoint: hostName
+          });
+        case 20:
+          nodes = _context6.sent;
+          if (!(nodes.length < 1)) {
+            _context6.next = 24;
+            break;
+          }
+          status.error = "No node matching stream URL " + streamUrl.href;
+          return _context6.abrupt("return", status);
+        case 24:
+          node = nodes[0];
+          status.node = node;
+          endpoint = node.endpoints[0];
+          this.SetNodes({
+            fabricURIs: [endpoint]
+          });
+
+          // Probe the stream
+          probe = {};
+          controller = new AbortController();
+          timeoutId = setTimeout(function () {
+            controller.abort();
+          }, 60 * 1000); // milliseconds
+          _context6.prev = 31;
+          _context6.next = 34;
+          return this.Rep({
+            libraryId: libraryId,
+            objectId: conf.objectId,
+            rep: "probe"
+          });
+        case 34:
+          probeUrl = _context6.sent;
+          _context6.t0 = this.utils;
+          _context6.next = 38;
+          return HttpClient.Fetch(probeUrl, {
+            body: JSON.stringify({
+              "filename": streamUrl.href,
+              "listen": true
+            }),
+            method: "POST",
+            signal: controller.signal
+          });
+        case 38:
+          _context6.t1 = _context6.sent;
+          _context6.next = 41;
+          return _context6.t0.ResponseToJson.call(_context6.t0, _context6.t1);
+        case 41:
+          probe = _context6.sent;
+          if (probe) {
+            clearTimeout(timeoutId);
+          }
+          if (!probe.errors) {
+            _context6.next = 45;
+            break;
+          }
+          throw probe.errors[0];
+        case 45:
+          _context6.next = 54;
+          break;
+        case 47:
+          _context6.prev = 47;
+          _context6.t2 = _context6["catch"](31);
+          if (!(_context6.t2.code === "ETIMEDOUT")) {
+            _context6.next = 53;
+            break;
+          }
+          throw "Stream probe time out - make sure the stream source is available";
+        case 53:
+          throw _context6.t2;
+        case 54:
+          console.log("PROBE", probe);
+          probe.format.filename = streamUrl.href;
+
+          // Create live recording config
+          lc = new LiveConf(probe, node.id, endpoint, false, false, true);
+          liveRecordingConfigStr = lc.generateLiveConf({
+            audioBitrate: customSettings.audioBitrate,
+            audioIndex: customSettings.audioIndex,
+            partTtl: customSettings.partTtl,
+            channelLayout: customSettings.channelLayout
+          });
+          liveRecordingConfig = JSON.parse(liveRecordingConfigStr);
+          console.log("CONFIG", JSON.stringify(liveRecordingConfig.live_recording));
+
+          // Store live recording config into the stream object
+          _context6.next = 62;
+          return this.EditContentObject({
+            libraryId: libraryId,
+            objectId: conf.objectId
+          });
+        case 62:
+          e = _context6.sent;
+          writeToken = e.write_token;
+          _context6.next = 66;
+          return this.ReplaceMetadata({
+            libraryId: libraryId,
+            objectId: conf.objectId,
+            writeToken: writeToken,
+            metadataSubtree: "live_recording",
+            metadata: liveRecordingConfig.live_recording
+          });
+        case 66:
+          _context6.next = 68;
+          return this.ReplaceMetadata({
+            libraryId: libraryId,
+            objectId: conf.objectId,
+            writeToken: writeToken,
+            metadataSubtree: "probe",
+            metadata: probe
+          });
+        case 68:
+          _context6.next = 70;
+          return this.FinalizeContentObject({
+            libraryId: libraryId,
+            objectId: conf.objectId,
+            writeToken: writeToken,
+            commitMessage: "Apply live stream configuration"
+          });
+        case 70:
+          status.fin = _context6.sent;
+          return _context6.abrupt("return", status);
+        case 72:
+        case "end":
+          return _context6.stop();
+      }
+    }, _callee6, this, [[31, 47]]);
+  }));
+  return function (_x6) {
+    return _ref12.apply(this, arguments);
+  };
+}();
+
+// const ChannelStatus = async ({client, name}) => {
+//
+//   let status = {name: name};
+//
+//   const conf = channels[name];
+//   if(conf === null) {
+//     console.log("Bad name: ", name);
+//     return;
+//   }
+//
+//   try {
+//
+//     let meta = await client.ContentObjectMetadata({
+//       libraryId: conf.libraryId,
+//       objectId: conf.objectId
+//     });
+//
+//     status.channel_title = meta.public.asset_metadata.title;
+//     let source = meta.channel.offerings.default.items[0].source["/"];
+//     let hash = source.split("/")[2];
+//     status.stream_hash = hash;
+//     latestHash = await client.LatestVersionHash({
+//       versionHash: hash
+//     });
+//     status.stream_latest_hash = latestHash;
+//
+//     if(hash != latestHash) {
+//       status.warnings = ["Stream version is not the latest"];
+//     }
+//
+//     let channelFormatsUrl = await client.FabricUrl({
+//       libraryId: conf.libraryId,
+//       objectId: conf.objectId,
+//       rep: "channel/options.json"
+//     });
+//
+//     try {
+//       let offerings = await got(channelFormatsUrl);
+//       status.offerings = JSON.parse(offerings.body);
+//     } catch(error) {
+//       console.log(error);
+//       status.offerings_error = "Failed to retrieve channel offerings";
+//     }
+//
+//     status.playout = await ChannelPlayout({client, libraryId: conf.libraryId, objectId: conf.objectId});
+//
+//   } catch(error) {
+//     console.error(error);
+//   }
+//
+//   return status;
+// };
+
+/*
+ * Performs client-side playout operations - open the channel, read offerings,
+ * retrieve playlist and one video init segment.
+ */
+// const ChannelPlayout = async({client, libraryId, objectId}) => {
+//
+//   let playout = {};
+//
+//   const offerings = await client.AvailableOfferings({
+//     libraryId,
+//     objectId,
+//     handler: "channel",
+//     linkPath: "/public/asset_metadata/offerings"
+//   });
+//
+//   // Choosing offering 'default'
+//   let offering = offerings.default;
+//
+//   const playoutOptions = await client.PlayoutOptions({
+//     libraryId,
+//     objectId,
+//     offeringURI: offering.uri
+//   });
+//
+//   // Retrieve master playlist
+//   let masterPlaylistUrl = playoutOptions["hls"]["playoutMethods"]["fairplay"]["playoutUrl"];
+//   playout.master_playlist_url = masterPlaylistUrl;
+//   try {
+//     //let masterPlaylist =  await got(masterPlaylistUrl);
+//     playout.master_playlist = "success";
+//   } catch(error) {
+//     playout.master_playlist = "fail";
+//   }
+//
+//   let url = new URL(masterPlaylistUrl);
+//   let p = url.pathname.split("/");
+//
+//   // Retrieve media playlist
+//   p[p.length - 1] = "video/720@14000000/live.m3u8";
+//   let pathMediaPlaylist = p.join("/");
+//   url.pathname = pathMediaPlaylist;
+//   let mediaPlaylistUrl = url.toString();
+//   playout.media_playlist_url = mediaPlaylistUrl;
+//   let mediaPlaylist;
+//   try {
+//     mediaPlaylist = await got(mediaPlaylistUrl);
+//     playout.media_playlist = "success";
+//   } catch(error) {
+//     playout.media_playlist = "fail";
+//   }
+//
+//   // Retrieve init segment
+//   var regex = new RegExp("^#EXT-X-MAP:URI=\"init.m4s.(.*)\"$", "m");
+//   var match = regex.exec(mediaPlaylist.body);
+//   let initQueryParams;
+//   if(match) {
+//     initQueryParams = match[1];
+//   }
+//
+//   p[p.length - 1] = "video/720@14000000/init.m4s";
+//   let pathInit = p.join("/");
+//   url.pathname = pathInit;
+//   url.search=initQueryParams;
+//   let initUrl = url.toString();
+//   playout.init_segment_url = initUrl;
+//   /*
+//   try {
+// 	let initSegment = await got(initUrl);
+// 	playout.init_segment = "success"
+//   } catch(error) {
+// 	playout.init_segment = "fail";
+//   }
+// */
+//   return playout;
+// };
+
+// const Summary = async ({client}) => {
+//
+//   let summary = {};
+//
+//   try {
+//     for (const [key] of Object.entries(streams)) {
+//       conf = streams[key];
+//       summary[key] = await Status({client, name: key, stopLro: false});
+//     }
+//
+//   } catch(error) {
+//     console.error(error);
+//   }
+//   return summary;
+// };
+
+// const ChannelSummary = async ({client}) => {
+//
+//   let summary = {};
+//
+//   try {
+//     for (const [key] of Object.entries(channels)) {
+//       conf = channels[key];
+//       summary[key] = await ChannelStatus({client, name: key});
+//     }
+//
+//   } catch(error) {
+//     console.error(error);
+//   }
+//   return summary;
+// };
+
+// const ConfigStreamRebroadcast = async () => {
+//
+//   const t = 1619850660;
+//
+//   try {
+//     let client;
+//     if(conf.clientConf.configUrl) {
+//       client = await ElvClient.FromConfigurationUrl({
+//         configUrl: conf.clientConf.configUrl
+//       });
+//     } else {
+//       client = new ElvClient(conf.clientConf);
+//     }
+//     const wallet = client.GenerateWallet();
+//     const signer = wallet.AddAccount({ privateKey: conf.signerPrivateKey });
+//     client.SetSigner({ signer });
+//     const fabURI = client.fabricURIs[0];
+//     console.log("Fabric URI: " + fabURI);
+//     const ethURI = client.ethereumURIs[0];
+//     console.log("Ethereum URI: " + ethURI);
+//
+//     client.ToggleLogging(false);
+//
+//     let mainMeta = await client.ContentObjectMetadata({
+//       libraryId: conf.libraryId,
+//       objectId: conf.objectId
+//     });
+//     console.log("Main meta:", mainMeta);
+//
+//     edgeWriteToken = mainMeta.edge_write_token;
+//     console.log("Edge: ", edgeWriteToken);
+//
+//     let edgeMeta = await client.ContentObjectMetadata({
+//       libraryId: conf.libraryId,
+//       objectId: conf.objectId,
+//       writeToken: edgeWriteToken
+//     });
+//     console.log("Edge meta:", edgeMeta);
+//
+//     //console.log("CONFIG: ", edgeMeta.live_recording_parameters.live_playout_config);
+//     console.log("recording_start_time: ", edgeMeta.recording_start_time);
+//     console.log("recording_stop_time:  ", edgeMeta.recording_stop_time);
+//
+//     // Set rebroadcast start
+//     edgeMeta.live_recording_parameters.live_playout_config.rebroadcast_start_time_sec_epoch = t;
+//
+//     if(PRINT_DEBUG) console.log("MergeMetadata", conf.libraryId, conf.objectId, writeToken);
+//     await client.MergeMetadata({
+//       libraryId: conf.libraryId,
+//       objectId: conf.objectId,
+//       writeToken: edgeWriteToken,
+//       metadata: {
+//         "live_recording_parameters": {
+//           "live_playout_config" : edgeMeta.live_recording_parameters.live_playout_config
+//         }
+//       }
+//     });
+//
+//   } catch(error) {
+//     console.error(error);
+//   }
+// };
+
+// async function EnsureAll() {
+//   client = await StatusPrep({name: null});
+//   let summary = await Summary({client});
+//
+//   var res = {
+//     running: 0,
+//     stalled: 0,
+//     terminated: 0
+//   };
+//
+//   try {
+//     for (const [key, value] of Object.entries(summary)) {
+//       if(value.state === "stalled") {
+//         console.log("Stream stalled: ", key, " - restarting");
+//         console.log("todo ...");
+//       }
+//       res[value.state] = res[value.state] + 1;
+//     }
+//   } catch(error) {
+//     console.error(error);
+//   }
+//
+//   return res;
+// }
+
+/*
+ * Original Run() function - kept for reference
+ */
+// async function Run() {
+//
+//   var client;
+//
+//   switch (command) {
+//
+//     case "start":
+//       StartStream({name});
+//       break;
+//
+//     case "status":
+//       client = await StatusPrep({name});
+//       let status = await Status({client, name, stopLro: false});
+//       console.log(JSON.stringify(status, null, 4));
+//       break;
+//
+//     case "stop":
+//       client = await UpdatePrep({name});
+//       Status({client, name, stopLro: true});
+//       break;
+//
+//     case "summary":
+//       client = await StatusPrep({name: null});
+//       let summary = await Summary({client});
+//       console.log(JSON.stringify(summary, null, 4));
+//       break;
+//
+//     case "init": // Set up DRM
+//       SetOfferingAndDRM();
+//       break;
+//
+//     case "reset": // Stop and start LRO recording (same edge write token)
+//       client = await StatusPrep({name});
+//       let reset = await Reset({client, name, stopLro: false});
+//       console.log(JSON.stringify(reset, null, 4));
+//       break;
+//
+//     case "channel":
+//       client = await StatusPrep({name});
+//       let channelStatus = await ChannelStatus({client, name});
+//       console.log(JSON.stringify(channelStatus, null, 4));
+//       break;
+//
+//     case "channel_summary":
+//       client = await StatusPrep({name});
+//       let channelSummary = await ChannelSummary({client, name});
+//       console.log(JSON.stringify(channelSummary, null, 4));
+//       break;
+//
+//     case "ensure_all": // Check all and restart stalled
+//       let ensureSummary = await EnsureAll();
+//       console.log(JSON.stringify(ensureSummary, null, 4));
+//       break;
+//
+//     case "future_use_config":
+//       ConfigStreamRebroadcast();
+//       break;
+//
+//     default:
+//       console.log("Bad command: ", command);
+//       break;
+//
+//   }
+// }