@eluvio/elv-client-js 4.0.48 → 4.0.50

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eluvio/elv-client-js",
-  "version": "4.0.48",
+  "version": "4.0.50",
   "description": "Javascript client for the Eluvio Content Fabric",
   "main": "src/index.js",
   "author": "Kevin Talmadge",

package/src/ElvClient.js

@@ -571,78 +571,78 @@ class ElvClient {
    *
    * @methodGroup Nodes
    * @namedParams
-   * @param {string} - matchEndpoint
-   * @param {string} - matchNodeId
+   * @param {string=} matchEndpoint - Return node(s) matching the specified endpoint
+   * @param {string=} matchNodeId - Return node(s) matching the specified node ID
    *
-   * @return {Array<Object>} - A list of nodes in the space
+   * @return {Array<Object>} - A list of nodes in the space matching the parameters
    */
-  async SpaceNodes({matchEndpoint, matchNodeId}) {
+  async SpaceNodes({matchEndpoint, matchNodeId}={}) {
     let bign = await this.CallContractMethod({
       contractAddress: this.contentSpaceAddress,
       methodName: "numActiveNodes",
     });
     let n = bign.toNumber();
-    let nodes = [];
 
-    for (let i = 0; i < n; i ++) {
+    return (await Utils.LimitedMap(
+      5,
+      [...new Array(n)],
+      async (_, index) => {
+        let bigi = Ethers.BigNumber.from(index);
+        let addr = await this.CallContractMethod({
+          contractAddress: this.contentSpaceAddress,
+          methodName: "activeNodeAddresses",
+          methodArgs: [bigi],
+          formatArguments: true
+        });
 
-      let bigi = Ethers.BigNumber.from(i);
-      let addr = await this.CallContractMethod({
-        contractAddress: this.contentSpaceAddress,
-        methodName: "activeNodeAddresses",
-        methodArgs: [bigi],
-        formatArguments: true
-      });
+        let locatorsHex = await this.CallContractMethod({
+          contractAddress: this.contentSpaceAddress,
+          methodName: "activeNodeLocators",
+          methodArgs: [bigi]
+        });
 
-      let locatorsHex = await this.CallContractMethod({
-        contractAddress: this.contentSpaceAddress,
-        methodName: "activeNodeLocators",
-        methodArgs: [bigi]
-      });
+        let nodeId = this.utils.AddressToNodeId(addr);
 
-      let nodeId = this.utils.AddressToNodeId(addr);
+        if(matchNodeId &&nodeId !== matchNodeId) {
+          return;
+        }
 
-      if (matchNodeId != undefined && nodeId != matchNodeId) {
-        continue; // Not a match
-      }
+        let node = {id: nodeId, endpoints: []};
 
-      let node = {id: nodeId, endpoints: []};
+        // Parse locators CBOR
+        let buffer = locatorsHex.slice(2, locatorsHex.length); // Skip "0x"
+        let hex = buffer.toString("hex");
+        let locators = CBOR.decodeAllSync(hex);
 
-      // Parse locators CBOR
-      let buffer = locatorsHex.slice(2, locatorsHex.length); // Skip "0x"
-      let hex = buffer.toString("hex");
-      let locators = CBOR.decodeAllSync(hex);
+        let match = false;
 
-      let match = false;
+        if(locators.length >= 5) {
+          let fabArray = locators[4].fab;
+          if(fabArray) {
+            for(let i = 0; i < fabArray.length; i ++) {
+              let host = fabArray[i].host;
 
-      if(locators.length >= 5) {
-        let fabArray = locators[4].fab;
-        if(fabArray != undefined) {
-          for(let i = 0; i < fabArray.length; i ++) {
-            let host = fabArray[i].host;
+              if(matchEndpoint && !matchEndpoint.includes(host)) {
+                continue; // Not a match
+              }
 
-            if(matchEndpoint != undefined && !host.includes(matchEndpoint)) {
-              continue; // Not a match
-            }
+              match = true;
+              let endpoint = fabArray[i].scheme + "://" + host;
 
-            match = true;
-            let endpoint = fabArray[i].scheme + "://" + host;
+              if(fabArray[i].port) {
+                endpoint = endpoint + ":" + fabArray[i].port;
+              }
 
-            if(fabArray[i].port != "") {
-              endpoint = endpoint + ":" + fabArray[i].port;
+              endpoint = endpoint + "/" + fabArray[i].path;
+              node.endpoints.push(endpoint);
             }
-
-            endpoint = endpoint + "/" + fabArray[i].path;
-            node.endpoints.push(endpoint);
           }
         }
-      }
-      if(match) {
-        nodes.push(node);
-      }
-    }
 
-    return nodes;
+        return match ? node : undefined;
+      }
+    ))
+      .filter(n => n);
   }
 
   /**

package/src/client/LiveConf.js

@@ -131,7 +131,7 @@ class LiveConf {
 
   getStreamDataForCodecType(codecType) {
     let stream = null;
-    for (let index = 0; index < this.probeData.streams.length; index++) {
+    for(let index = 0; index < this.probeData.streams.length; index++) {
       if(this.probeData.streams[index].codec_type == codecType) {
         stream = this.probeData.streams[index];
       }
@@ -166,7 +166,7 @@ class LiveConf {
     let frameRate = videoStream.frame_rate;
 
     let seg ={};
-    switch (frameRate) {
+    switch(frameRate) {
       case "24":
         seg.video = 30 * sourceTimescale;
         seg.audio = 30 * 48000;
@@ -225,7 +225,7 @@ class LiveConf {
   syncAudioToStreamIdValue() {
     let sync_id = -1;
     let videoStream = this.getStreamDataForCodecType("video");
-    switch (this.probeKind()) {
+    switch(this.probeKind()) {
       case "udp":
         sync_id = videoStream.stream_id;
         break;

package/src/client/LiveStream.js

@@ -68,12 +68,12 @@ exports.StreamStatus = async function({name, stopLro=false, showParams=false}) {
       ]
     });
 
-    if (mainMeta.live_recording_config == undefined || mainMeta.live_recording_config.url == undefined) {
+    if(mainMeta.live_recording_config == undefined || mainMeta.live_recording_config.url == undefined) {
       status.state = "unconfigured";
       return status;
     }
 
-    if (mainMeta.live_recording == undefined || mainMeta.live_recording.fabric_config == undefined ||
+    if(mainMeta.live_recording == undefined || mainMeta.live_recording.fabric_config == undefined ||
       mainMeta.live_recording.playout_config == undefined || mainMeta.live_recording.recording_config == undefined) {
       status.state = "uninitialized";
       return status;
@@ -96,7 +96,7 @@ exports.StreamStatus = async function({name, stopLro=false, showParams=false}) {
     status.url = mainMeta.live_recording.recording_config.recording_params.origin_url;
 
     let edgeWriteToken = mainMeta.live_recording.fabric_config.edge_write_token;
-    if (edgeWriteToken == undefined) {
+    if(edgeWriteToken == undefined) {
       status.state = "inactive";
       return status;
     }
@@ -157,7 +157,7 @@ exports.StreamStatus = async function({name, stopLro=false, showParams=false}) {
     if((edgeMeta.live_recording.playout_config.interleaves != undefined) &&
       (edgeMeta.live_recording.playout_config.interleaves[sequence] != undefined)) {
       let insertions = edgeMeta.live_recording.playout_config.interleaves[sequence];
-      for (let i = 0; i < insertions.length; i ++) {
+      for(let i = 0; i < insertions.length; i ++) {
         let insertionTimeSinceEpoch = recording_period.start_time_epoch_sec + insertions[i].insertion_time;
         status.insertions[i] = {
           insertion_time_since_start: insertions[i].insertion_time,
@@ -190,7 +190,7 @@ exports.StreamStatus = async function({name, stopLro=false, showParams=false}) {
       state = "starting";
     } else if(state === "running" && sinceLastFinalize > 32.9) {
       state = "stalled";
-    } else if (state == "terminated") {
+    } else if(state == "terminated") {
       state = "stopped";
     }
     status.state = state;
@@ -493,7 +493,7 @@ exports.StreamStartOrStopOrReset = async function({name, op}) {
 
     // Wait until LRO is 'starting'
     let tries = 10;
-    while (status.state != "starting" && tries-- > 0) {
+    while(status.state != "starting" && tries-- > 0) {
       console.log("Wait to start - ", status.state);
       await sleep(1000);
       status = await this.StreamStatus({name});
@@ -505,7 +505,7 @@ exports.StreamStartOrStopOrReset = async function({name, op}) {
   } catch(error) {
     console.error(error);
   }
-}
+};
 
 /*
  * Stop the live stream session and close the edge write token.
@@ -943,7 +943,7 @@ exports.LoadConf = async function({name}) {
   }
 
   return conf;
-}
+};
 
 /*
  * Read a playable contnet object and get information about a particular offering
@@ -1122,108 +1122,105 @@ exports.StreamConfig = async function({name}) {
   let conf = await this.LoadConf({name});
   let status = {name};
 
-  try {
-    let libraryId = await this.ContentObjectLibraryId({objectId: conf.objectId});
-    status.library_id = libraryId;
-    status.object_id = conf.objectId;
-
-    let mainMeta = await this.ContentObjectMetadata({
-      libraryId: libraryId,
-      objectId: conf.objectId
-    });
-
-    let userConfig = mainMeta.live_recording_config;
-    status.user_config = userConfig;
+  let libraryId = await this.ContentObjectLibraryId({objectId: conf.objectId});
+  status.library_id = libraryId;
+  status.object_id = conf.objectId;
 
-    // Get node URI from user config
-    const hostName = userConfig.url.replace("udp://", "").split(":")[0];
-    const streamUrl = new URL(userConfig.url);
+  let mainMeta = await this.ContentObjectMetadata({
+    libraryId: libraryId,
+    objectId: conf.objectId
+  });
 
-    console.log("Retrieving nodes...");
-    let nodes = await this.SpaceNodes({matchEndpoint: hostName});
-    if(nodes.length < 1) {
-      status.error = "No node matching stream URL " + streamUrl.href;
-      return status;
-    }
-    const node = nodes[0];
-    status.node = node;
-
-    let endpoint = node.endpoints[0];
-    this.SetNodes({fabricURIs: [endpoint]});
-
-    // Probe the stream
-    let probe = {};
-    const controller = new AbortController();
-    const timeoutId = setTimeout(() => {
-      controller.abort();
-    }, 60 * 1000); // milliseconds
-    try {
+  let userConfig = mainMeta.live_recording_config;
+  status.user_config = userConfig;
 
-      let probeUrl = await this.Rep({
-        libraryId,
-        objectId: conf.objectId,
-        rep: "probe"
-      });
+  // Get node URI from user config
+  const hostName = userConfig.url.replace("udp://", "").replace("rtmp://", "").split(":")[0];
+  const streamUrl = new URL(userConfig.url);
 
-      probe = await this.utils.ResponseToJson(
-        await HttpClient.Fetch(probeUrl, {
-          body: JSON.stringify({
-            "filename": streamUrl.href,
-            "listen": true
-          }),
-          method: "POST",
-          signal: controller.signal
-        })
-      );
+  console.log("Retrieving nodes...");
+  let nodes = await this.SpaceNodes({matchEndpoint: hostName});
+  if(nodes.length < 1) {
+    status.error = "No node matching stream URL " + streamUrl.href;
+    return status;
+  }
+  const node = nodes[0];
+  status.node = node;
+
+  let endpoint = node.endpoints[0];
+  this.SetNodes({fabricURIs: [endpoint]});
+
+  // Probe the stream
+  let probe = {};
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => {
+    controller.abort();
+  }, 60 * 1000); // milliseconds
+  try {
 
-      if(probe) { clearTimeout(timeoutId); }
-    } catch(error) {
-      if(error.code === "ETIMEDOUT") {
-        status.error = "Stream probe time out - make sure the stream source is available";
-      } else {
-        console.log("Stream probe failed", error);
-      }
-    }
+    let probeUrl = await this.Rep({
+      libraryId,
+      objectId: conf.objectId,
+      rep: "probe"
+    });
 
-    probe.format.filename = streamUrl.href;
-    console.log("PROBE", probe);
+    probe = await this.utils.ResponseToJson(
+      await HttpClient.Fetch(probeUrl, {
+        body: JSON.stringify({
+          "filename": streamUrl.href,
+          "listen": true
+        }),
+        method: "POST",
+        signal: controller.signal
+      })
+    );
 
-    // Create live reocording config
-    let lc = new LiveConf(probe, node.id, endpoint, false, false, true);
+    if(probe) { clearTimeout(timeoutId); }
 
-    const liveRecordingConfigStr = lc.generateLiveConf();
-    let liveRecordingConfig = JSON.parse(liveRecordingConfigStr);
-    console.log("CONFIG", JSON.stringify(liveRecordingConfig.live_recording));
+    if(probe.errors) {
+      throw probe.errors[0];
+    }
+  } catch(error) {
+    if(error.code === "ETIMEDOUT") {
+      throw "Stream probe time out - make sure the stream source is available";
+    } else {
+      throw error;
+    }
+  }
 
-    // Store live recording config into the stream object
-    let e = await this.EditContentObject({
-      libraryId,
-      objectId: conf.objectId
-    });
-    let writeToken = e.write_token;
+  console.log("PROBE", probe);
+  probe.format.filename = streamUrl.href;
 
-    await this.ReplaceMetadata({
-      libraryId,
-      objectId: conf.objectId,
-      writeToken,
-      metadataSubtree: "live_recording",
-      metadata: liveRecordingConfig.live_recording
-    });
+  // Create live reocording config
+  let lc = new LiveConf(probe, node.id, endpoint, false, false, true);
 
-    let fin = await this.FinalizeContentObject({
-      libraryId,
-      objectId: conf.objectId,
-      writeToken,
-      commitMessage: "Apply live stream configuration"
-    });
+  const liveRecordingConfigStr = lc.generateLiveConf();
+  let liveRecordingConfig = JSON.parse(liveRecordingConfigStr);
+  console.log("CONFIG", JSON.stringify(liveRecordingConfig.live_recording));
 
-    status.fin = fin;
+  // Store live recording config into the stream object
+  let e = await this.EditContentObject({
+    libraryId,
+    objectId: conf.objectId
+  });
+  let writeToken = e.write_token;
+
+  await this.ReplaceMetadata({
+    libraryId,
+    objectId: conf.objectId,
+    writeToken,
+    metadataSubtree: "live_recording",
+    metadata: liveRecordingConfig.live_recording
+  });
 
-    return status;
+  status.fin = await this.FinalizeContentObject({
+    libraryId,
+    objectId: conf.objectId,
+    writeToken,
+    commitMessage: "Apply live stream configuration"
+  });
 
-  } catch(e) {
-    console.log("ERROR", e);
-  }
+  return status;
 };
 
 // const ChannelStatus = async ({client, name}) => {