@eluvio/elv-client-js 4.0.135 → 4.0.137

package/src/walletClient/index.js

@@ -186,12 +186,19 @@ class ElvWalletClient {
     }
 
     try {
-      walletClient.topLevelInfo = await client.utils.ResponseToJson(
+      walletClient.topLevelInfoPromise = client.utils.ResponseToJson(
         client.MakeAuthServiceRequest({
           path: "/as/mw/toplevel",
           queryParams: {env: mode}
         })
-      );
+      )
+        .then(info => {
+          walletClient.topLevelInfo = info;
+
+          if(!skipMarketplaceLoad) {
+            walletClient.LoadAvailableMarketplaces();
+          }
+        });
     } catch(error) {
       // eslint-disable-next-line no-console
       console.error("Unable to load top level info:");
@@ -199,10 +206,6 @@ class ElvWalletClient {
       console.error(error);
     }
 
-    if(!skipMarketplaceLoad) {
-      await walletClient.LoadAvailableMarketplaces();
-    }
-
     return walletClient;
   }
 
@@ -823,6 +826,7 @@ class ElvWalletClient {
   }
 
   async LoadMarketplace(marketplaceParams) {
+    await this.topLevelInfoPromise;
     const marketplaceInfo = this.MarketplaceInfo({marketplaceParams});
 
     const marketplaceId = marketplaceInfo.marketplaceId;

package/utilities/FrontEndSimpleIngest.js

@@ -0,0 +1,198 @@
+const { ElvClient } = require("../../src/ElvClient");
+const fs = require('fs');
+const path = require('path');
+
+
+// Simple Media Ingest 
+// This script allows for the upload of a single media file from a Front End client with an authorization token
+// It creates a single playable object for each media file uploaded
+
+
+
+const MediaUpload = async () => {
+
+  //
+  // BACK END
+  //
+
+  let backendClient = await ElvClient.FromNetworkName({networkName: "demov3"});
+  let wallet = backendClient.GenerateWallet();
+  let backendSigner = wallet.AddAccount({
+    privateKey: process.env.PRIVATE_KEY
+  });
+  backendClient.SetSigner({signer: backendSigner});
+  // Send these 3 items to the front end: writeToken, authToken, node
+
+
+
+  // Constants from tenancy
+  const libraryId = "ilibxxxx;
+  const mezzType = "iq__xxxx";
+  const masterType = "iq__xxx";
+  const objectName = "Object Name";
+  const filePath = path.resolve(__dirname, 'abr_profile.json');
+  const abrProfile = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+
+
+
+  // Upload by creating a new object
+  const newObject = await backendClient.CreateContentObject({
+    libraryId, 
+    options: {
+    meta: {
+      public: {
+        name: objectName,
+      }
+    },
+    type: mezzType
+  }
+  })
+  const objectId = newObject.id;
+  const writeToken = newObject.write_token;
+
+
+
+
+  // Upload to an exisiting object
+  // const objectId = "iq__2o68yG4v44LwffBuKetPXGX79K9M"
+  // const writeToken = (await backendClient.EditContentObject({libraryId, objectId})).write_token;
+
+
+
+
+  // Generate auth token
+  const authToken = await backendClient.authClient.AuthorizationToken({libraryId, objectId, update: true});
+  const node = await backendClient.WriteTokenNodeUrl({writeToken});
+  console.log("Send to front end", "writeToken", writeToken, "authToken", authToken, "node", node);
+
+
+
+
+  //
+  // FRONT END
+  //
+
+  let frontendClient = await ElvClient.FromNetworkName({networkName: "demov3"});
+  frontendClient.SetNodes({fabricURIs: [node]});
+  frontendClient.SetStaticToken({token: authToken, update: true});
+
+  // Upload Files
+  const filePaths = [
+    "file/path/file_name.mp4",
+  ];
+  let fileInfo = [];
+  for (let i = 0; i < filePaths.length; i ++) {
+    const fd = fs.openSync(filePaths[i]);
+    const stats = fs.statSync(filePaths[i]);
+    fileInfo.push({
+      path: `file_name.mp4`,
+      type: "file",
+      size: stats.size,
+      data: fd
+    })
+  }
+
+  const callback = (fileUploadStatus) => {
+    console.log(fileUploadStatus);
+  };
+
+
+
+  
+  //
+  // BACK END
+  //
+
+  let backendClient2 = await ElvClient.FromNetworkName({networkName: "demov3"});
+  let wallet2 = backendClient.GenerateWallet();
+  let backendSigner2 = wallet2.AddAccount({
+    privateKey: process.env.PRIVATE_KEY
+  });
+  backendClient2.SetSigner({signer: backendSigner2});
+  backendClient2.SetNodes({fabricURIs: [node]});
+
+  // For debbuging purposes
+  // backendClient2.ToggleLogging(true);
+
+  try {
+
+    // Create Production Master
+    const createMasterResponse = await backendClient2.CreateProductionMaster({
+      libraryId,
+      objectId,
+      fileInfo,
+      callback,
+      encrypt: true,
+      type: masterType,
+      name: objectName,
+      writeToken
+    })
+    console.log("Master Response", createMasterResponse);
+
+    // Create ABR Mezzanine
+    const createABRMezzResponse = await backendClient2.CreateABRMezzanine({
+      libraryId,
+      writeToken,
+      objectId,
+      type: mezzType,
+      masterWriteToken: writeToken,
+      variant: "default",
+      offeringKey: "default",
+      abrProfile
+    });
+    console.log("Create ABR Mezzanine", createABRMezzResponse);
+
+
+    // Start ABR Job
+    const startJobsResponse = await backendClient2.StartABRMezzanineJobs({
+      libraryId,
+      objectId,
+      offeringKey: "default",
+      writeToken
+    });
+
+    const lroWriteToken = startJobsResponse.lro_draft.write_token;
+    const lroNode = startJobsResponse.lro_draft.node;
+    const lroData = startJobsResponse.data;
+
+    console.log("LRO Write Token", lroWriteToken);
+    console.log("LRO Node", lroNode);
+    console.log("LRO Data", lroData);
+
+
+    // Check ABR Job is Finished
+    let done = false;
+    while (!done) {
+      const lroStatus = await backendClient.LROStatus({ libraryId, objectId, writeToken });
+      console.log("LRO Status", lroStatus);
+      const lastStatus = lroData.every(lro => lroStatus[lro]?.run_state === "finished")
+      console.log(lastStatus);
+      if (lastStatus) done = true;
+    }   
+
+
+
+
+    // Finalize Mezzanine Object
+    if (done) {
+      let finalizeAbrResponse = await backendClient2.FinalizeABRMezzanine({
+        libraryId,
+        objectId,
+        writeToken,
+        offeringKey: "default"
+      });
+      console.log("Finalize ABR", finalizeAbrResponse);
+
+      let finalizeContentObject = await backendClient2.FinalizeContentObject({
+        libraryId,
+        objectId,
+        writeToken,
+      });
+      console.log("Finalize Object", finalizeContentObject);
+    }
+  } catch(e) {
+    console.log("ERROR", e);
+  }
+}
+
+MediaUpload();

package/utilities/ProductionMasterCreate.js

@@ -33,6 +33,11 @@ class ProductionMasterCreate extends Utility {
         NewOpt("streams", {
           descTemplate: "JSON string (or file path if prefixed with '@') containing stream specifications for variant in new production master",
           type: "string"
+        }),
+        NewOpt("writeToken", {
+          demand: false,
+          descTemplate: "Write token of the draft",
+          type: "string",
         })
       ]
     };
@@ -77,7 +82,7 @@ class ProductionMasterCreate extends Utility {
     const client = await this.concerns.Client.get();
 
     const type = await await this.concerns.ArgType.typVersionHash();
-    const {libraryId, s3Copy, s3Reference} = this.args;
+    const {libraryId, s3Copy, s3Reference, writeToken} = this.args;
 
 
     const createResponse = await client.CreateProductionMaster({
@@ -90,7 +95,8 @@ class ProductionMasterCreate extends Utility {
       encrypt: !unencrypted,
       access,
       copy: s3Copy && !s3Reference,
-      callback: (access ? this.concerns.CloudFile : this.concerns.LocalFile).callback
+      callback: (access ? this.concerns.CloudFile : this.concerns.LocalFile).callback,
+      writeToken
     });
 
     const {errors, warnings, id} = createResponse;
@@ -149,6 +155,7 @@ class ProductionMasterCreate extends Utility {
         libraryId,
         objectId: id,
         versionHash: hash,
+        writeToken: write_token,
         metadataSubtree: "/production_master/variants/default/streams"
       }));
       if(!streamsFromServer.hasOwnProperty("audio")) {

package/utilities/SampleIngest.js

@@ -0,0 +1,225 @@
+// 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 ArgTenant = require("./lib/concerns/ArgTenant");
+const {seconds} = require("./lib/helpers");
+const AbrProfile = require("./lib/abr_profiles/abr_profile_clear.json");
+
+class SampleIngest extends Utility {
+  blueprint() {
+    return {
+      concerns: [Client, Finalize, LocalFile, ArgLibraryId, ArgTenant, 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 type from Tenant
+    const tenantInfo = await this.concerns.ArgTenant.tenantInfo();
+
+    const type = tenantInfo.typeTitle;
+
+    if(R.isNil(type)) throw Error("Library does not specify content type for sample ingests");
+
+    const {drm, libraryId, title} = this.args;
+    const encrypt = true;
+
+    const {id, writeToken} = await client.CreateContentObject({
+      libraryId,
+      options: type ? { type } : {}
+    });
+
+    logger.log("Uploading files...");
+
+    const createMasterResponse = await client.CreateProductionMaster({
+      libraryId,
+      type,
+      name: title,
+      description: `Media object created via sample ingest: ${title}`,
+      fileInfo,
+      encrypt,
+      copy: true,
+      callback: this.concerns.LocalFile.callback,
+      writeToken
+    });
+
+    // 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}`,
+      `  Write token: ${writeToken}`,
+      ""
+    );
+
+    if(!R.isNil(createMasterResponse.errors) && !R.isEmpty(createMasterResponse.errors)) throw Error(`Error(s) encountered while inspecting uploaded files: ${createMasterResponse.errors.join("\n")}`);
+
+    // get production master metadata
+    const masterMetadata = (await client.ContentObjectMetadata({
+      libraryId,
+      objectId: id,
+      writeToken,
+      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, AbrProfile);
+    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,
+      writeToken,
+      type,
+      masterWriteToken: writeToken,
+      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")}`);
+
+    logger.log("Starting conversion to streaming format...");
+
+    const startJobsResponse = await client.StartABRMezzanineJobs({
+      libraryId,
+      objectId: id,
+      offeringKey: "default",
+      writeToken
+    });
+
+    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}`,
+      ""
+    );
+
+    logger.log("Progress:");
+
+    const lro = this.concerns.LRO;
+    let done = false;
+    let lastStatus;
+    while(!done) {
+      const statusMap = await lro.status({libraryId, objectId: id, writeToken}); // 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,
+      writeToken,
+      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")}`);
+
+    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 sample ingest";
+  }
+}
+
+if(require.main === module) {
+  Utility.cmdLineInvoke(SampleIngest);
+} else {
+  module.exports = SampleIngest;
+}