@eluvio/elv-client-js 4.0.86 → 4.0.87

package/package.json

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

package/src/ContentObjectAudit.js

@@ -0,0 +1,98 @@
+const UrlJoin = require("url-join");
+const HttpClient = require("./HttpClient");
+const UUID = require("uuid").v4;
+
+const {ValidateParameters} = require("./Validation");
+
+const ContentObjectAudit = {
+  async AuditContentObject({client, libraryId, objectId, versionHash, salt, samples, live=false}) {
+    if(!salt){
+      salt = client.utils.B64(UUID());
+    }
+
+    if(!samples) {
+      samples = [
+        Math.random() * 0.33,
+        Math.random() * 0.33 + 0.33,
+        Math.random() * 0.33 + 0.66
+      ];
+    }
+
+    // Ensure only a max of 3 samples
+    samples = samples.slice(0, 3);
+
+    if(versionHash) {
+      objectId = client.utils.DecodeVersionHash(versionHash).objectId;
+    }
+
+    if(!libraryId) {
+      libraryId = await client.ContentObjectLibraryId({objectId});
+    }
+
+    ValidateParameters({libraryId, objectId, versionHash});
+
+    let queryParams = {salt, samples};
+
+
+    if(live) {
+      queryParams.now = Date.now();
+    }
+
+    // Test against the node the client is currently using, plus a batch of fresh nodes
+    const uris = [
+      client.HttpClient.uris[client.HttpClient.uriIndex],
+      ...(await client.Configuration({
+        configUrl: client.configUrl,
+        clientIP: client.clientIP,
+        region: client.region
+      })).fabricURIs
+    ]
+      .filter((v, i, s) => s.indexOf(v) === i);
+
+    const httpClient = new HttpClient({uris});
+
+    let path = UrlJoin("qlibs", libraryId, "q", versionHash || objectId, live ? "call/live/audit" : "audit");
+    let responses = await httpClient.RequestAll({
+      headers: await client.authClient.AuthorizationHeader({libraryId, objectId, versionHash}),
+      queryParams: queryParams,
+      method: "GET",
+      path
+    });
+
+    let auditHash, verified;
+    let audits = [];
+    for(const response of responses) {
+      let url = new URL(response.url);
+      let audit = { host: url.hostname };
+
+      if(!response.ok) {
+        audit.error = response;
+        audit.errorMessage = response.message || JSON.stringify(response);
+      } else {
+        let res = await client.utils.ResponseToJson(response);
+        if(auditHash === undefined) {
+          auditHash = res.audit_hash;
+        } else if(res.audit_hash !== auditHash) {
+          verified = false;
+        } else if(verified === undefined) {
+          verified = true;
+        }
+
+        audit.audit_hash = res.audit_hash;
+      }
+
+      audits.push(audit);
+    }
+
+    verified = verified || false;
+
+    return {
+      verified,
+      salt,
+      samples,
+      audits,
+    };
+  },
+};
+
+module.exports = ContentObjectAudit;

package/src/ElvClient.js

@@ -9,8 +9,6 @@ const EthClient = require("./EthClient");
 const UserProfileClient = require("./UserProfileClient");
 const HttpClient = require("./HttpClient");
 const RemoteSigner = require("./RemoteSigner");
-
-// const ContentObjectVerification = require("./ContentObjectVerification");
 const Utils = require("./Utils");
 const Crypto = require("./Crypto");
 const {LogMessage} = require("./LogMessage");
@@ -161,6 +159,8 @@ class ElvClient {
     assumeV3=false,
     service="default"
   }) {
+    this.Configuration = ElvClient.Configuration;
+
     this.utils = Utils;
 
     this.contentSpaceId = contentSpaceId;
@@ -390,6 +390,8 @@ class ElvClient {
     });
 
     client.configUrl = configUrl;
+    client.region = region;
+    client.clientIP = clientIP;
 
     return client;
   }
@@ -469,6 +471,8 @@ class ElvClient {
       region
     });
 
+    this.region = region;
+
     this.authServiceURIs = authServiceURIs;
     this.fabricURIs = fabricURIs;
     this.ethereumURIs = ethereumURIs;

package/src/FrameClient.js

@@ -318,6 +318,8 @@ class FrameClient {
       "AddContentObjectGroupPermission",
       "AddLibraryContentType",
       "AssetMetadata",
+      "AuditContentObject",
+      "AuditStream",
       "AvailableDRMs",
       "AvailableOfferings",
       "AwaitPending",
@@ -497,7 +499,6 @@ class FrameClient {
       "UploadPartChunk",
       "UploadStatus",
       "UseRegion",
-      "VerifyContentObject",
       "Visibility",
       "WriteTokenNodeUrl"
     ];

package/src/HttpClient.js

@@ -15,8 +15,9 @@ class HttpClient {
     this.retries = Math.max(3, uris.length);
   }
 
-  BaseURI() {
-    return new URI(this.uris[this.uriIndex]);
+  BaseURI(uriIndex) {
+    if(uriIndex === undefined) { uriIndex = this.uriIndex; }
+    return new URI(this.uris[uriIndex]);
   }
 
   static Fetch(url, params={}) {
@@ -59,9 +60,10 @@ class HttpClient {
     attempts=0,
     allowFailover=true,
     forceFailover=false,
-    allowRetry=true
+    allowRetry=true,
+    uriIndex
   }) {
-    let baseURI = this.BaseURI();
+    let baseURI = this.BaseURI(uriIndex);
 
     // If URL contains a write token, it must go to the correct server and can not fail over
     const writeTokenMatch = path.replace(/^\//, "").match(/(qlibs\/ilib[a-zA-Z0-9]+|q|qid)\/(tqw__[a-zA-Z0-9]+)/);
@@ -141,6 +143,7 @@ class HttpClient {
           bodyType,
           headers,
           attempts: attempts + 1,
+          uriIndex,
           forceFailover
         });
       }
@@ -176,6 +179,35 @@ class HttpClient {
     return response;
   }
 
+  async RequestAll({
+    method,
+    path,
+    queryParams={},
+    body,
+    bodyType="JSON",
+    headers={},
+  }) {
+    return await Promise.all(
+      Array.from(new Array(this.uris.length).keys())
+        .map(async uriIndex => {
+          try {
+            return await this.Request({
+              method,
+              path,
+              queryParams,
+              body,
+              bodyType,
+              headers,
+              allowFailover: false,
+              uriIndex
+            });
+          } catch(error) {
+            return error;
+          }
+        })
+    );
+  }
+
   URL({path, queryParams={}}) {
     let baseURI = this.BaseURI();
 

package/src/client/ContentAccess.js

@@ -8,6 +8,7 @@ const UrlJoin = require("url-join");
 const objectPath = require("object-path");
 
 const HttpClient = require("../HttpClient");
+const ContentObjectAudit = require("../ContentObjectAudit");
 
 const {
   ValidateLibrary,
@@ -3054,24 +3055,26 @@ exports.Collection = async function({collectionType}) {
 /* Verification */
 
 /**
- * Verify the specified content object
+ * Audit the specified content object against several content fabric nodes
  *
  * @methodGroup Content Objects
  * @namedParams
- * @param {string} libraryId - ID of the library
- * @param {string} objectId - ID of the object
- * @param {string} versionHash - Hash of the content object version
+ * @param {string=} libraryId - ID of the library
+ * @param {string=} objectId - ID of the object
+ * @param {string=} versionHash - Version hash of the object -- if not specified, latest version is returned
+ * @param {string=} salt - base64-encoded byte sequence for salting the audit hash
+ * @param {Array<number>=} samples - list of percentages (0.0 - <1.0) used for sampling the content part list, up to 3
  *
- * @returns {Promise<Object>} - Response describing verification results
+ * @returns {Promise<Object>} - Response describing audit results
  */
-exports.VerifyContentObject = async function({libraryId, objectId, versionHash}) {
-  ValidateParameters({libraryId, objectId, versionHash});
-
-  return await ContentObjectVerification.VerifyContentObject({
+exports.AuditContentObject = async function({libraryId, objectId, versionHash, salt, samples}) {
+  return await ContentObjectAudit.AuditContentObject({
     client: this,
     libraryId,
     objectId,
-    versionHash
+    versionHash,
+    salt,
+    samples
   });
 };
 

package/src/client/LiveConf.js

@@ -157,7 +157,7 @@ class LiveConf {
           recordingBitrate: Math.max(this.probeData.streams[index].bit_rate, 128000),
           recordingChannels: this.probeData.streams[index].channels,
           playoutLabel: `Audio ${index}`
-        }
+        };
       }
     }
     return audioStreams;
@@ -382,36 +382,36 @@ class LiveConf {
     return sync_id;
   }
 
- /*
+  /*
   * Generate audio streams recording configuration based on the optional custom settings.
   * If no custom "audio" section is present, record all the acceptable audio streams found in the probe
   */
   generateAudioStreamsConfig({customSettings}) {
 
     let audioStreams = {};
-    if (customSettings && customSettings.audio) {
-      for (let i = 0; i < Object.keys(customSettings.audio).length; i ++) {
+    if(customSettings && customSettings.audio) {
+      for(let i = 0; i < Object.keys(customSettings.audio).length; i ++) {
         let audioIdx = Object.keys(customSettings.audio)[i];
         let audio = customSettings.audio[audioIdx];
         audioStreams[audioIdx] = {
           recordingBitrate: audio.recording_bitrate || 192000,
           recordingChannels: audio.recording_channels || 2,
         };
-        if (audio.playout) {
-          audioStreams[audioIdx].playoutLabel = audio.playout_label || `Audio ${audioIdx}`
+        if(audio.playout) {
+          audioStreams[audioIdx].playoutLabel = audio.playout_label || `Audio ${audioIdx}`;
         }
       }
     }
 
     // If no audio streams specified in custom config, set up all the suitable audio streams in the probe
-    if (!customSettings.audio) {
+    if(!customSettings.audio) {
       audioStreams = this.getAudioStreamsFromProbe();
     }
 
     return audioStreams;
   }
 
- /*
+  /*
   * Generate the live recording config as required by QFAB, based on defaults and optional custom settings.
   */
   generateLiveConf({customSettings}) {
@@ -439,7 +439,7 @@ class LiveConf {
     conf.live_recording.recording_config.recording_params.xc_params.enc_height = videoStream.height;
     conf.live_recording.recording_config.recording_params.xc_params.enc_width = videoStream.width;
 
-    for (let i =0; i < Object.keys(audioStreams).length; i ++) {
+    for(let i =0; i < Object.keys(audioStreams).length; i ++) {
       conf.live_recording.recording_config.recording_params.xc_params.audio_index[i] = parseInt(Object.keys(audioStreams)[i]);
     }
 
@@ -549,7 +549,7 @@ class LiveConf {
     let globalAudioBitrate = 0;
     let nAudio = 0;
 
-    for (let i = 0; i < Object.keys(audioStreams).length; i ++ ) {
+    for(let i = 0; i < Object.keys(audioStreams).length; i ++ ) {
       let audioLadderSpec = {...LadderSpecAudio};
       const audioIndex = Object.keys(audioStreams)[i];
       const audio = audioStreams[audioIndex];
@@ -561,7 +561,7 @@ class LiveConf {
       audioLadderSpec.stream_label = audio.playoutLabel ? audio.playoutLabel : null;
 
       conf.live_recording.recording_config.recording_params.ladder_specs.push(audioLadderSpec);
-      if (audio.recordingBitrate > globalAudioBitrate) {
+      if(audio.recordingBitrate > globalAudioBitrate) {
         globalAudioBitrate = audio.recordingBitrate;
       }
       nAudio ++;

package/src/client/LiveStream.js

@@ -10,6 +10,7 @@ const fs = require("fs");
 const HttpClient = require("../HttpClient");
 const Fraction = require("fraction.js");
 const {ValidateObject, ValidatePresence} = require("../Validation");
+const ContentObjectAudit = require("../ContentObjectAudit");
 
 const MakeTxLessToken = async({client, libraryId, objectId, versionHash}) => {
   const tok = await client.authClient.AuthorizationToken({libraryId, objectId,
@@ -445,7 +446,7 @@ exports.StreamStatus = async function({name, stopLro=false, showParams=false}) {
     let videoLastFinalizationTimeEpochSec = -1;
     let videoFinalizedParts = 0;
     let sinceLastFinalize = -1;
-    if (period.finalized_parts_info && period.finalized_parts_info.video && period.finalized_parts_info.video.last_finalization_time) {
+    if(period.finalized_parts_info && period.finalized_parts_info.video && period.finalized_parts_info.video.last_finalization_time) {
       videoLastFinalizationTimeEpochSec = period.finalized_parts_info.video.last_finalization_time / 1000000;
       videoFinalizedParts = period.finalized_parts_info.video.n_parts;
       sinceLastFinalize = Math.floor(new Date().getTime() / 1000) - videoLastFinalizationTimeEpochSec;
@@ -733,7 +734,7 @@ exports.StreamCreate = async function({name, start=false}) {
 */
 exports.StreamStartOrStopOrReset = async function({name, op}) {
   try {
-    let status = await this.StreamStatus({name})
+    let status = await this.StreamStatus({name});
     if(status.state != "stopped") {
       if(op === "start") {
         status.error = "Unable to start stream - state: " + status.state;
@@ -1937,3 +1938,27 @@ exports.StreamAddWatermark = async function({
 
   return response;
 };
+
+/**
+ * Audit the specified live stream against several content fabric nodes
+ *
+ * @methodGroup Live Stream
+ * @namedParams
+ * @param {string=} objectId - Object ID of the live stream
+ * @param {string=} versionHash - Version hash of the live stream -- if not specified, latest version is returned
+ * @param {string=} salt - base64-encoded byte sequence for salting the audit hash
+ * @param {Array<number>=} samples - list of percentages (0.0 - <1.0) used for sampling the content part list, up to 3
+ *
+ * @returns {Promise<Object>} - Response describing audit results
+ */
+exports.AuditStream = async function({objectId, versionHash, salt, samples}) {
+  return await ContentObjectAudit.AuditContentObject({
+    client: this,
+    libraryId,
+    objectId,
+    versionHash,
+    salt,
+    samples,
+    live: true
+  });
+};

package/src/ContentObjectVerification.js

@@ -1,210 +0,0 @@
-const CBOR = require("cbor");
-const SJCL = require("sjcl");
-const MultiHash = require("multihashes");
-const DeepEqual = require("deep-equal");
-const Utils = require("./Utils");
-
-const ContentObjectVerification = {
-  async VerifyContentObject({client, libraryId, objectId, versionHash}) {
-    let response = {
-      hash: versionHash
-    };
-
-    const partHash = Utils.DecodeVersionHash(versionHash).partHash;
-
-    const qpartsResponse = await client.QParts({libraryId, objectId, partHash, format: "arrayBuffer"})
-      .then(response => Buffer.from(response));
-    const partVerification = ContentObjectVerification._VerifyPart({partHash: partHash, qpartsResponse: qpartsResponse});
-
-    if(partVerification.valid) {
-      response.qref = { valid: true };
-    } else {
-      response.qref = { valid: false, error: partVerification.error.message };
-    }
-
-    response.qref.hash = partHash;
-
-    if(response.qref.valid) {
-      // Validate Metadata
-      const qmdHash = partVerification.cbor.QmdHash.value;
-      const metadataPartHash = "hqp_" + MultiHash.toB58String(qmdHash.slice(1, qmdHash.length));
-      const metadataPartResponse = await client.QParts({libraryId, objectId, partHash: metadataPartHash, format: "arrayBuffer"})
-        .then(response => Buffer.from(response));
-
-      const metadataVerification = ContentObjectVerification._VerifyPart({partHash: metadataPartHash, qpartsResponse: metadataPartResponse});
-
-      if(metadataVerification.valid) {
-        response.qmd = { valid: true };
-      } else {
-        response.qmd = { valid: false, error: metadataVerification.error.message };
-      }
-
-      response.qmd.hash = metadataPartHash;
-
-      if(response.qmd.valid && libraryId) {
-        // If the library ID is provided, compare some metadata in the CBOR response
-        // to the metadata from the /meta endpoint
-        const metadata = await client.ContentObjectMetadata({
-          libraryId: libraryId,
-          objectId,
-          versionHash: partHash.replace("hqp_", "hq__")
-        });
-
-        response.qmd.check = ContentObjectVerification._VerifyMetadata({metadataCbor: metadataVerification.cbor, metadata: metadata});
-      }
-
-      // Validate Qstruct
-
-      const qstructHash = partVerification.cbor.QstructHash.value;
-      const structPartHash = "hqp_" + MultiHash.toB58String(qstructHash.slice(1, qstructHash.length));
-      const structPartResponse = await client.QParts({libraryId, objectId, partHash: structPartHash, format: "arrayBuffer"})
-        .then(response => Buffer.from(response));
-      const structVerification = ContentObjectVerification._VerifyPart({partHash: structPartHash, qpartsResponse: structPartResponse});
-
-      if(structVerification.valid) {
-        response.qstruct = { valid: true };
-      } else {
-        response.qstruct = { valid: false, error: structVerification.error.message };
-      }
-
-      response.qstruct.hash = structPartHash;
-
-      if(response.qstruct.valid) {
-        response.qstruct.parts = ContentObjectVerification._FormatQStruct(structVerification.cbor.Parts);
-      }
-    }
-
-    response.valid =
-      response.qref.valid &&
-      response.qmd.valid &&
-      response.qstruct.valid &&
-      (!response.qmd.check || response.qmd.check.valid);
-
-    return response;
-  },
-
-  // Content verification methods //
-
-  _FormatQStruct(structParts) {
-    if(!structParts) { return []; }
-
-    return structParts.map(structPart => {
-      return {
-        hash: "hqp_" + MultiHash.toB58String(structPart.Hash.value.slice(1, structPart.Hash.length)),
-        size: structPart.Size
-      };
-    });
-  },
-
-  _Hash(thing) {
-    function fromBits(arr) {
-      var out = [], bl = SJCL.bitArray.bitLength(arr), i, tmp;
-      for(i=0; i<bl/8; i++) {
-        if((i&3) === 0) {
-          tmp = arr[i/4];
-        }
-        out.push(tmp >>> 24);
-        tmp <<= 8;
-      }
-      return out;
-    }
-
-    function toBits(bytes) {
-      var out = [], i, tmp=0;
-      for(i=0; i<bytes.length; i++) {
-        tmp = tmp << 8 | bytes[i];
-        if((i&3) === 3) {
-          out.push(tmp);
-          tmp = 0;
-        }
-      }
-      if(i&3) {
-        out.push(SJCL.bitArray.partial(8*(i&3), tmp));
-      }
-      return out;
-    }
-
-    let digest = SJCL.hash.sha256.hash(toBits(thing));
-    let bytes = fromBits(digest);
-    let out = Buffer.from(bytes, "binary");
-
-    return MultiHash.toB58String(MultiHash.encode(out, "sha2-256"));
-  },
-
-  _ParseCBOR(cborResponse) {
-    let buffer = cborResponse.slice(7, cborResponse.length);
-    let hex = buffer.toString("hex");
-    return CBOR.decodeFirstSync(hex);
-  },
-
-  _VerifyPart({partHash, qpartsResponse}) {
-    try {
-      if(ContentObjectVerification._Hash(qpartsResponse) !== partHash.replace("hqp_", "")) {
-        throw Error("Hashes do not match");
-      }
-
-      let cbor = ContentObjectVerification._ParseCBOR(qpartsResponse);
-
-      return {
-        valid: true,
-        cbor: cbor
-      };
-    } catch(error) {
-      return {
-        valid: false,
-        error: error
-      };
-    }
-  },
-
-  _VerifyMetadata({metadataCbor, metadata}) {
-    if(!metadataCbor) { metadataCbor = {}; }
-    if(!metadata) { metadata = {}; }
-
-    let response = {
-      valid: true,
-      invalidValues: []
-    };
-
-    const cborKeys = Object.keys(metadataCbor);
-    const metadataKeys = Object.keys(metadata);
-
-    // Find any difference between top level keys
-    const differentKeys = cborKeys
-      .filter(x => !metadataKeys.includes(x))
-      .concat(metadataKeys.filter(x => !cborKeys.includes(x)));
-
-    for(const key of differentKeys) {
-      const cborValue = metadataCbor[key];
-      const metadataValue = metadata[key];
-
-      response.invalidValues.push({
-        key: key,
-        cborValue: cborValue,
-        metadataValue: metadataValue
-      });
-    }
-
-    // Deep comparison of up to 5 keys
-    for(const fieldToValidate of Object.keys(metadataCbor).slice(0, 5)) {
-      const cborValue = metadataCbor[fieldToValidate];
-      const metadataValue = metadata[fieldToValidate];
-
-      if(!DeepEqual(cborValue, metadataValue)) {
-        response.invalidValues.push({
-          key: fieldToValidate,
-          cborValue: cborValue,
-          metadataValue: metadataValue
-        });
-      }
-    }
-
-    if(response.invalidValues.length !== 0) {
-      response.valid = false;
-    }
-
-    return response;
-  },
-};
-
-module.exports = ContentObjectVerification;