@eluvio/elv-client-js 4.0.135 → 4.0.137

package/utilities/SampleIngestWithMaster.js

@@ -0,0 +1,226 @@
+// 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("Tenant does not specify content type for titles");
+
+    const {drm, libraryId, title} = this.args;
+    const encrypt = true;
+
+    logger.log("Uploading files...");
+
+    const createMasterResponse = await client.CreateProductionMaster({
+      libraryId,
+      type,
+      name: `${title} MASTER`,
+      description: `Media object created via sample 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 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}`,
+      ""
+    );
+
+    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,
+      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, 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 {writeToken} = await client.CreateContentObject({
+      libraryId,
+      options: type ? { type } : {}
+    });
+
+    const createMezResponse = await client.CreateABRMezzanine({
+      name: `${title} MEZ`,
+      libraryId,
+      type,
+      writeToken,
+      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")}`);
+
+    logger.log("Starting conversion to streaming format...");
+
+    const startJobsResponse = await client.StartABRMezzanineJobs({
+      libraryId,
+      objectId: createMezResponse.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: createMezResponse.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: createMezResponse.id
+    });
+  }
+
+  header() {
+    return "Create playable media object via sample ingest";
+  }
+}
+
+if(require.main === module) {
+  Utility.cmdLineInvoke(SampleIngest);
+} else {
+  module.exports = SampleIngest;
+}

package/utilities/lib/concerns/ArgLibraryId.js

@@ -40,4 +40,4 @@ const New = context => {
 module.exports = {
   blueprint,
   New
-};
+};

package/utilities/lib/concerns/ArgTenant.js

@@ -0,0 +1,23 @@
+// code related to tenant
+
+const Tenant = require("./Tenant");
+
+const blueprint = {
+  name: "ArgTenant",
+  concerns: [Tenant],
+  options: []
+};
+
+const New = context => {
+  const tenantInfo = async () => await context.concerns.Tenant.info();
+
+  // instance interface
+  return {
+    tenantInfo
+  };
+};
+
+module.exports = {
+  blueprint,
+  New
+};

package/utilities/lib/concerns/ContentType.js

@@ -46,4 +46,4 @@ const New = context => {
   };
 };
 
-module.exports = {blueprint, New};
+module.exports = {blueprint, New};

package/utilities/lib/concerns/Finalize.js

@@ -35,12 +35,17 @@ const New = context => {
     let publishFinished = false;
     let latestObjectData = {};
     while(!publishFinished) {
-      latestObjectData = await client.ContentObject({libraryId, objectId});
-      if(latestObjectData.hash === latestHash) {
-        logger.log("New object version now available");
-        publishFinished = true;
-      } else {
-        logger.log("  new version not available yet, waiting 15 seconds...");
+      try {
+        latestObjectData = await client.ContentObject({libraryId, objectId});
+        if(latestObjectData.hash === latestHash) {
+          logger.log("New object version now available");
+          publishFinished = true;
+        } else {
+          logger.log("  new version not available yet, waiting 15 seconds...");
+          await seconds(15);
+        }
+      } catch(error) {
+        console.error(`Waiting for master object publishing hash: ${latestHash}. Retrying.`, error);
         await seconds(15);
       }
     }
@@ -52,4 +57,4 @@ const New = context => {
 module.exports = {
   blueprint,
   New
-};
+};

package/utilities/lib/concerns/LRO.js

@@ -73,9 +73,9 @@ const New = context => {
     statusEntry.run_state = state;
   };
 
-  const status = async ({libraryId, objectId}) => {
+  const status = async ({libraryId, objectId, writeToken}) => {
     const client = await context.concerns.Client.get();
-    const statusMap = await client.LROStatus({libraryId, objectId}); // TODO: check how offering key is used, if at all
+    const statusMap = await client.LROStatus({libraryId, objectId, writeToken}); // TODO: check how offering key is used, if at all
 
     if(kindOf(statusMap)==="undefined") throw Error("Received no job status information from server - object already finalized?");
     return statusMapProcess(statusMap);
@@ -151,4 +151,4 @@ module.exports = {
   STATE_STALLED,
   STATE_BAD_PCT,
   STATE_ERROR,
-};
+};

package/utilities/lib/concerns/Tenant.js

@@ -0,0 +1,47 @@
+// code related to tenant data
+const Client = require("./Client");
+const Logger = require("./Logger");
+
+const blueprint = {
+  name: "Tenant",
+  concerns: [Client, Logger]
+};
+
+const New = context => {
+  const logger = context.concerns.Logger;
+
+  const info = async () => {
+    const client = await context.concerns.Client.get();
+    const tenantId = await client.userProfileClient.TenantContractId();
+    logger.log(`Getting info for tenant ${tenantId}...`);
+
+    const metadata = await client.ContentObjectMetadata({
+      libraryId: tenantId.replace("iten", "ilib"),
+      objectId: tenantId.replace("iten", "iq__"),
+      metadataSubtree: "public",
+      select: [
+        "sites/live_streams",
+        "content_types/live_stream",
+        "content_types/title"
+      ]
+    });
+
+    const typeTitle = metadata.content_types && metadata.content_types.title;
+    const typeLiveStream = metadata.content_types && metadata.content_types.live_stream;
+    const sitesLiveStream = metadata.sites && metadata.sites.live_streams;
+
+    return {
+      typeTitle,
+      typeLiveStream,
+      sitesLiveStream,
+      tenantId
+    };
+  };
+
+  return {info};
+};
+
+module.exports = {
+  blueprint,
+  New
+};