@eluvio/elv-client-js 3.1.93 → 3.1.96

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eluvio/elv-client-js",
-  "version": "3.1.93",
+  "version": "3.1.96",
   "description": "Javascript client for the Eluvio Content Fabric",
   "main": "src/ElvClient.js",
   "author": "Kevin Talmadge",
@@ -57,6 +57,7 @@
   "dependencies": {
     "@babel/runtime": "^7.8.4",
     "@eluvio/crypto": ">=1.0.8",
+    "@eluvio/elv-abr-profile": "^1.0.0",
     "@sindresorhus/slugify": "^1.1.0",
     "babel-loader": "^8.0.6",
     "bignumber.js": "^8.0.2",

package/src/AuthorizationClient.js

@@ -204,7 +204,7 @@ class AuthorizationClient {
       addr: Utils.FormatAddress(((this.client.signer && this.client.signer.address) || ""))
     };
 
-    if(!(this.noAuth || noAuth) && !this.client.signer.remoteSigner) {
+    if(!(this.noAuth || noAuth)) {
       const { transactionHash } =  await this.MakeAccessRequest({
         libraryId,
         objectId,

package/src/ElvClient.js

@@ -694,6 +694,67 @@ class ElvClient {
     return this.utils.FormatAddress(this.signer.address);
   }
 
+  /*
+    TOKEN                  211b  PREFIX + BODY | aplsjcJf1HYcDDUuCdXcSZtU86nYK162YmYJeuqwMczEBJVkD5D5EvsBvVwYDRsf4hzDvBWMoe9piBpqx...
+    PREFIX                   6b  aplsjc | apl=plain s=ES256K jc=json-compressed
+    BODY                   205b  base58(SIGNATURE + PAYLOAD)
+    SIGNATURE + PAYLOAD    151b  151b * 138 / 100 + 1 = 209b (>= 205b)
+    SIGNATURE               66b  ES256K_Di9Lu83mz4wMoehCEeQhKpJJ7ApmDZLumAa2Cge48F6EHYnbn8msATGGpjucScwimei1TWGd7aeyQY45AdXd5tT1Z
+    PAYLOAD                 85b  json-compressed
+    json                    79b  {"adr":"VVf4DQU357tDnZGYQeDrntRJ5rs=","spc":"ispc3ANoVSzNA3P6t7abLR69ho5YPPZU"}
+   */
+
+  /**
+   * Create a signed authorization token that can be used to authorize against the fabric
+   *
+   * @methodGroup Authorization
+   * @namedParams
+   * @param {number} duration=86400000 - Time until the token expires, in milliseconds (1 hour = 60 * 60 * 1000 = 3600000). Default is 24 hours.
+   * @param {Object=} spec - Additional attributes for this token
+   * @param {string=} address - Address of the signing account - if not specified, the current signer address will be used.
+   * @param {function=} Sign - If specified, this function will be used to produce the signature instead of the client's current signer
+   * @param {boolean=} addEthereumPrefix=true - If specified, the 'Ethereum Signed Message' prefixed hash format will be performed. Disable this if the provided Sign method already does this (e.g. Metamask)
+   */
+  async CreateFabricToken({
+    duration=24 * 60 * 60 * 1000,
+    spec={},
+    address,
+    Sign,
+    addEthereumPrefix=true,
+  }={}) {
+    address = address || this.CurrentAccountAddress();
+
+    let token = {
+      ...spec,
+      sub:`iusr${Utils.AddressToHash(address)}`,
+      adr: Buffer.from(address.replace(/^0x/, ""), "hex").toString("base64"),
+      spc: await this.ContentSpaceId(),
+      iat: Date.now(),
+      exp: Date.now() + duration,
+    };
+
+    if(!Sign) {
+      Sign = async message => this.authClient.Sign(message);
+    }
+
+    let message = `Eluvio Content Fabric Access Token 1.0\n${JSON.stringify(token)}`;
+
+    if(addEthereumPrefix) {
+      message = Ethers.utils.keccak256(Buffer.from(`\x19Ethereum Signed Message:\n${message.length}${message}`, "utf-8"));
+    }
+
+    const signature = await Sign(message);
+
+    const compressedToken = Pako.deflateRaw(Buffer.from(JSON.stringify(token), "utf-8"));
+    return `acspjc${this.utils.B58(
+      Buffer.concat([
+        Buffer.from(signature.replace(/^0x/, ""), "hex"),
+        Buffer.from(compressedToken)
+      ])
+    )}`;
+  }
+
+
   /**
    * Issue a self-signed authorization token
    *
@@ -705,7 +766,7 @@ class ElvClient {
    * @param {string=} policyId - The object ID of the policy for this token
    * @param {string=} subject - The subject of the token
    * @param {string} grantType=read - Permissions to grant for this token. Options: "access", "read", "create", "update", "read-crypt"
-   * @param {number} duration - Time until the token expires, in milliseconds (1 hour = 60 * 60 * 1000)
+   * @param {number} duration - Time until the token expires, in milliseconds (1 hour = 60 * 60 * 1000 = 3600000)
    * @param {boolean} allowDecryption=false - If specified, the re-encryption key will be included in the token,
    * enabling the user of this token to download encrypted content from the specified object
    * @param {Object=} context - Additional JSON context

package/src/RemoteSigner.js

@@ -85,24 +85,28 @@ class RemoteSigner extends Ethers.Signer {
    */
   async signDigest(digest) {
     if(!this.signatureCache[digest]) {
-      this.signatureCache[digest] = new Promise(async resolve => {
-        let signature = await Utils.ResponseToJson(
-          this.HttpClient.Request({
-            method: "POST",
-            path: UrlJoin("as", "wlt", "sign", "eth", this.id),
-            headers: {
-              Authorization: `Bearer ${this.authToken}`
-            },
-            body: {
-              hash: digest
-            }
-          })
-        );
-
-        signature.v = parseInt(signature.v, 16);
-        signature.recoveryParam = signature.v - 27;
-
-        resolve(signature);
+      this.signatureCache[digest] = new Promise(async (resolve, reject) => {
+        try {
+          let signature = await Utils.ResponseToJson(
+            this.HttpClient.Request({
+              method: "POST",
+              path: UrlJoin("as", "wlt", "sign", "eth", this.id),
+              headers: {
+                Authorization: `Bearer ${this.authToken}`
+              },
+              body: {
+                hash: digest
+              }
+            })
+          );
+
+          signature.v = parseInt(signature.v, 16);
+          signature.recoveryParam = signature.v - 27;
+
+          resolve(signature);
+        } catch(error) {
+          reject(error);
+        }
       });
     }
 

package/src/client/ABRPublishing.js

@@ -478,7 +478,7 @@ exports.StartABRMezzanineJobs = async function({
     metadata: lroInfo
   });
 
-  await this.FinalizeContentObject({
+  const finalizeResponse = await this.FinalizeContentObject({
     libraryId,
     objectId,
     writeToken: statusDraft.write_token,
@@ -500,6 +500,7 @@ exports.StartABRMezzanineJobs = async function({
   });
 
   return {
+    hash: finalizeResponse.hash,
     lro_draft: lroInfo,
     writeToken: processingDraft.write_token,
     data,

package/src/client/ContentAccess.js

@@ -2332,6 +2332,10 @@ exports.LinkData = async function({libraryId, objectId, versionHash, writeToken,
 /* Encryption */
 
 exports.CreateEncryptionConk = async function({libraryId, objectId, versionHash, writeToken, createKMSConk=true}) {
+  if(this.signer.remoteSigner) {
+    return;
+  }
+
   ValidateParameters({libraryId, objectId, versionHash});
   ValidateWriteToken(writeToken);
 

package/testScripts/Test.js

@@ -13,25 +13,6 @@ const Test = async () => {
     });
 
     client.SetSigner({signer});
-
-
-    const ethUrl = "https://host-216-66-40-19.contentfabric.io/eth";
-    const asUrl = "https://host-66-220-3-86.contentfabric.io";
-
-    client.SetNodes({
-      ethereumURIs: [
-        ethUrl
-      ],
-      authServiceURIs: [
-        asUrl
-      ]
-    });
-
-    console.log(
-      await client.ContentObjectTenantId({
-        objectId: "iq__3PXRZX5NCzPQsfTEquCctB2K3KJh"
-      })
-    )
   } catch(error) {
     console.error(error);
     console.error(JSON.stringify(error, null, 2));

package/testScripts/VariantABRProfile.js

@@ -0,0 +1,45 @@
+/* eslint-disable no-console */
+
+
+const ScriptVariant = require("./parentClasses/ScriptVariant");
+const ABR = require("@eluvio/elv-abr-profile");
+
+class VariantABRProfile extends ScriptVariant {
+
+  async body() {
+    const client = await this.client();
+
+    const libraryId = this.args.libraryId;
+    const objectId = this.args.objectId;
+
+    // get media info from production master
+    const masterMetadata = await client.ContentObjectMetadata({
+      libraryId,
+      objectId,
+      metadataSubtree: "/production_master"
+    });
+
+    // adapt ABR Profile to production master's video properties
+    const generatedProfile = ABR.ABRProfileForVariant(
+      masterMetadata.sources,
+      masterMetadata.variants.default
+    );
+
+    if(!generatedProfile.ok) {
+      console.error("Error generating ABR Profile:\n" + generatedProfile.errors.join("\n"));
+    } else {
+      console.log(JSON.stringify(generatedProfile.result, null, 2));
+    }
+  }
+
+  header() {
+    return `Generate ABR Profile for production master ${this.args.objectId}, default variant`;
+  }
+
+  options() {
+    return super.options();
+  }
+}
+
+const script = new VariantABRProfile;
+script.run();

package/utilities/ObjectSetPermission.js

@@ -9,7 +9,7 @@ const Logger = require("./lib/concerns/Logger");
 
 const permissionTypes = ["owner", "editable", "viewable", "listable", "public"];
 
-class ObjectAddGroupPerms extends Utility {
+class ObjectSetPermission extends Utility {
   blueprint() {
     return {
       concerns: [Logger, ArgObjectId, Client],
@@ -55,7 +55,7 @@ class ObjectAddGroupPerms extends Utility {
 }
 
 if(require.main === module) {
-  Utility.cmdLineInvoke(ObjectAddGroupPerms);
+  Utility.cmdLineInvoke(ObjectSetPermission);
 } else {
-  module.exports = ObjectAddGroupPerms;
-}
+  module.exports = ObjectSetPermission;
+}

package/utilities/SimpleIngest.js

@@ -0,0 +1,286 @@
+// Create new production master from specified file(s)
+const R = require("ramda");
+
+const {ModOpt, NewOpt} = require("./lib/options");
+const Utility = require("./lib/Utility");
+
+const ABR = require("@eluvio/elv-abr-profile");
+
+const Client = require("./lib/concerns/Client");
+const Finalize = require("./lib/concerns/Finalize");
+const LocalFile = require("./lib/concerns/LocalFile");
+const LRO = require("./lib/concerns/LRO");
+const ArgLibraryId = require("./lib/concerns/ArgLibraryId");
+const {seconds} = require("./lib/helpers");
+
+class SimpleIngest extends Utility {
+  blueprint() {
+    return {
+      concerns: [Client, Finalize, LocalFile, ArgLibraryId, LRO],
+      options: [
+        ModOpt("libraryId", {demand: true, forX: "new media object"}),
+        NewOpt("title", {
+          demand: true,
+          descTemplate: "Title for new media object",
+          type: "string"
+        }),
+        NewOpt("drm", {
+          default: false,
+          descTemplate: "Use DRM for playback",
+          type: "boolean"
+        }),
+        ModOpt("files", {forX: "for new media object"})
+      ]
+    };
+  }
+
+  async body() {
+    const logger = this.logger;
+
+    let fileHandles = [];
+    const fileInfo = this.concerns.LocalFile.fileInfo(fileHandles);
+
+    // delay getting elvClient until this point so script exits faster
+    // if there is a validation error above
+    const client = await this.concerns.Client.get();
+
+    // get metadata from Library
+    const libInfo = await this.concerns.ArgLibraryId.libInfo();
+
+    const type = R.path(["metadata", "abr", "mez_content_type"], libInfo);
+    if(R.isNil(type)) throw Error("Library does not specify content type for simple ingests");
+
+    const libABRProfile = R.path(["metadata", "abr", "default_profile"], libInfo);
+    if(R.isNil(libABRProfile)) throw Error("Library does not specify ABR profile for simple ingests");
+
+    const libMezManageGroups = R.path(["metadata", "abr", "mez_manage_groups"], libInfo);
+
+    const libMezPermission = R.path(["metadata", "abr", "mez_permission_level"], libInfo);
+
+    const {drm, libraryId, title} = this.args;
+    const encrypt = true;
+
+    logger.log("Uploading files...");
+
+    const createMasterResponse = await client.CreateProductionMaster({
+      libraryId,
+      type,
+      name: title,
+      description: `Media object created via simple ingest: ${title}`,
+      fileInfo,
+      encrypt,
+      copy: true,
+      callback: this.concerns.LocalFile.callback
+    });
+
+    const {id, hash} = createMasterResponse;
+    // Log object id immediately, in case of error later in script
+    // Don't log hash yet, it will change if --streams was provided (or any other revision to object is needed)
+    logger.data("object_id", id);
+
+    // Close file handles (if any)
+    this.concerns.LocalFile.closeFileHandles(fileHandles);
+
+    logger.errorsAndWarnings(createMasterResponse);
+
+    logger.logList(
+      "",
+      "Production master default variant created:",
+      `  Object ID: ${id}`,
+      `  Version Hash: ${hash}`,
+      ""
+    );
+
+    logger.data("version_hash", hash);
+
+    if(!R.isNil(createMasterResponse.errors) && !R.isEmpty(createMasterResponse.errors)) throw Error(`Error(s) encountered while inspecting uploaded files: ${createMasterResponse.errors.join("\n")}`);
+
+    // TODO: replace with a 'waitForNewObject' call (Finalize.waitForPublish throws exception for brand new object not yet visible)
+    await seconds(2);
+
+    await this.concerns.Finalize.waitForPublish({
+      latestHash: hash,
+      libraryId,
+      objectId: id
+    });
+
+
+    // get production master metadata
+    const masterMetadata = (await client.ContentObjectMetadata({
+      libraryId,
+      objectId: id,
+      versionHash: hash,
+      metadataSubtree: "/production_master"
+    }));
+
+    const sources = R.prop("sources", masterMetadata);
+    const variant = R.path(["variants", "default"], masterMetadata);
+
+    // add info on source files and variant to data if --json selected
+    if(this.args.json) {
+      logger.data("media_files", sources);
+      logger.data("variant_default", variant);
+    }
+
+    // generate ABR profile
+    const genProfileRetVal = ABR.ABRProfileForVariant(sources, variant, libABRProfile);
+    if(!genProfileRetVal.ok) throw Error(`Error(s) encountered while generating ABR profile: ${genProfileRetVal.errors.join("\n")}`);
+
+    // filter DRM/clear as needed
+    const filterProfileRetVal = drm ?
+      ABR.ProfileExcludeClear(genProfileRetVal.result) :
+      ABR.ProfileExcludeDRM(genProfileRetVal.result);
+    if(!filterProfileRetVal.ok) throw Error(`Error(s) encountered while setting playout formats: ${filterProfileRetVal.errors.join("\n")}`);
+
+    // set up mezzanine offering
+    logger.log("Setting up media file conversion...");
+    const createMezResponse = await client.CreateABRMezzanine({
+      name: title,
+      libraryId,
+      objectId: id,
+      type,
+      masterVersionHash: hash,
+      variant: "default",
+      offeringKey: "default",
+      abrProfile: filterProfileRetVal.result
+    });
+
+    logger.errorsAndWarnings(createMezResponse);
+    const createMezErrors = createMezResponse.errors;
+    if(!R.isNil(createMezErrors) && !R.isEmpty(createMezErrors)) throw Error(`Error(s) encountered while setting up media file conversion: ${createMezErrors.join("\n")}`);
+
+    await this.concerns.Finalize.waitForPublish({
+      latestHash: createMezResponse.hash,
+      libraryId,
+      objectId: id
+    });
+
+
+    logger.log("Starting conversion to streaming format...");
+
+    const startJobsResponse = await client.StartABRMezzanineJobs({
+      libraryId,
+      objectId: id,
+      offeringKey: "default"
+    });
+
+    logger.errorsAndWarnings(startJobsResponse);
+    const startJobsErrors = createMezResponse.errors;
+    if(!R.isNil(startJobsErrors) && !R.isEmpty(startJobsErrors)) throw Error(`Error(s) encountered while starting file conversion: ${startJobsErrors.join("\n")}`);
+
+    const lroWriteToken = R.path(["lro_draft", "write_token"], startJobsResponse);
+    const lroNode = R.path(["lro_draft", "node"], startJobsResponse);
+
+    logger.data("library_id", libraryId);
+    logger.data("object_id", id);
+    logger.data("offering_key", "default");
+    logger.data("write_token", lroWriteToken);
+    logger.data("write_node", lroNode);
+
+    logger.logList(
+      "",
+      `Library ID: ${libraryId}`,
+      `Object ID: ${id}`,
+      "Offering: default",
+      `Write Token: ${lroWriteToken}`,
+      `Write Node: ${lroNode}`,
+      ""
+    );
+
+    // wait for latest version hash to become visible (if publish not finished, then checking progress can fail
+    // as metadata /lro_draft_default will not be found)
+
+    await this.concerns.Finalize.waitForPublish({
+      latestHash: startJobsResponse.hash,
+      libraryId,
+      objectId: id
+    });
+
+    logger.log("Progress:");
+
+    const lro = this.concerns.LRO;
+    let done = false;
+    let lastStatus;
+    while(!done) {
+      const statusMap = await lro.status({libraryId, objectId: id}); // TODO: check how offering key is used, if at all
+      const statusSummary = lro.statusSummary(statusMap);
+      lastStatus = statusSummary.run_state;
+      if(lastStatus !== LRO.STATE_RUNNING) done = true;
+      logger.log(`run_state: ${lastStatus}`);
+      const eta = statusSummary.estimated_time_left_h_m_s;
+      if(eta) logger.log(`estimated time left: ${eta}`);
+      await seconds(15);
+    }
+
+    const finalizeAbrResponse = await client.FinalizeABRMezzanine({
+      libraryId,
+      objectId: id,
+      offeringKey: "default"
+    });
+    const latestHash = finalizeAbrResponse.hash;
+
+    logger.errorsAndWarnings(finalizeAbrResponse);
+    const finalizeErrors = finalizeAbrResponse.errors;
+    if(!R.isNil(finalizeErrors) && !R.isEmpty(finalizeErrors)) throw Error(`Error(s) encountered while finalizing object: ${finalizeErrors.join("\n")}`);
+
+    if(libMezManageGroups && libMezManageGroups.length > 0){
+      for(const groupAddress of libMezManageGroups){
+        logger.log("Setting access permissions for managers");
+        await client.AddContentObjectGroupPermission({
+          objectId: id,
+          groupAddress,
+          permission: "manage"
+        });
+
+      }
+    }
+
+    if(libMezPermission) {
+      if(!["owner", "editable", "viewable", "listable", "public"].includes(libMezPermission)) {
+        logger.warn(`Bad value for mez_permission_level: '${libMezPermission}', skipping permission setting`);
+      } else {
+        logger.log(`Setting object permission to '${libMezPermission}'`);
+        const prevHash = await client.LatestVersionHash({objectId: id});
+
+        await client.SetPermission({
+          objectId: id,
+          permission: libMezPermission
+        });
+
+        const newHash = await client.LatestVersionHash({objectId: id});
+
+        if(prevHash === newHash) {
+          logger.log("Version hash unchanged: " + newHash );
+        } else {
+          logger.log("Previous version hash: " + prevHash );
+          logger.log("New version hash: " + newHash );
+        }
+        logger.data("version_hash", newHash);
+      }
+    }
+
+    logger.logList(
+      "",
+      "Playable media object created:",
+      `  Object ID: ${id}`,
+      `  Version Hash: ${latestHash}`,
+      ""
+    );
+    logger.data("version_hash", latestHash);
+    await this.concerns.Finalize.waitForPublish({
+      latestHash,
+      libraryId,
+      objectId: id
+    });
+  }
+
+  header() {
+    return "Create playable media object via simple ingest";
+  }
+}
+
+if(require.main === module) {
+  Utility.cmdLineInvoke(SimpleIngest);
+} else {
+  module.exports = SimpleIngest;
+}