@eluvio/elv-client-js 3.1.66 → 3.1.67

package/utilities/ChannelCreate.js

@@ -0,0 +1,205 @@
+const R = require("ramda");
+
+const {ModOpt, NewOpt, StdOpt} = require("./lib/options");
+const Utility = require("./lib/Utility");
+
+const ArgLibraryId = require("./lib/concerns/ArgLibraryId");
+const ArgType = require("./lib/concerns/ArgType");
+const FabricObject = require("./lib/concerns/FabricObject");
+const Version = require("./lib/concerns/Version");
+
+const STREAM_FIELDS = [
+  "aspect_ratio",
+  "channel_layout",
+  "channels",
+  "codec_name",
+  "codec_type",
+  "height",
+  "rate",
+  "width"
+];
+
+const itemParser = itemStr => {
+  const parsed = itemStr.split("/");
+  if(parsed.length !== 2) throw Error(`Failed to parse item '${itemStr} - each item should be a version hash + slash + offering key, e.g. 'hq__1234/default'`);
+  return {hash: parsed[0], offering: parsed[1]};
+};
+
+const mediaStructStreamFields = R.pick(STREAM_FIELDS);
+
+const msStreamsFieldSubset = R.map(mediaStructStreamFields);
+
+// return media_struct stream keys appearing in playout.streams.representations (usually only 1)
+const poStreamMsStreamKeys = poStream => R.uniq(R.map(R.prop("media_struct_stream_key"), poStream.representations));
+
+// return fields that need to be checked from media_struct.streams, include only streams referred to by playout.streams
+const msStreamFields = (poStreams, msStreams) => {
+  const msStreamKeys = R.uniq(R.values(R.map(poStreamMsStreamKeys, poStreams)));
+  const usedMsStreams = R.pick(msStreamKeys, msStreams);
+  return R.map(msStreamsFieldSubset, usedMsStreams);
+};
+
+const withoutDrmContentId = poFormat => {
+  const clone = R.clone(poFormat);
+  if(clone.drm) clone.drm.content_id = null;
+  return clone;
+};
+
+const withoutEncryptionSchemes = poStream => {
+  const clone = R.clone(poStream);
+  clone.encryption_schemes = null;
+  return clone;
+};
+
+
+class ChannelCreate extends Utility {
+  blueprint() {
+    return {
+      concerns: [ArgLibraryId, ArgType, FabricObject, Version],
+      options: [
+        ModOpt("libraryId", {demand: true}),
+        ModOpt("type", {demand: true}),
+        StdOpt("name",
+          {
+            demand: true,
+            forX: "channel object"
+          }),
+        NewOpt("items", {
+          demand: true,
+          descTemplate: "List of channel items, separated by spaces. Each item should be of form VERSION_HASH/OFFERING_KEY, e.g. hq__12345/default ",
+          string: true,
+          type: "array"
+        }),
+        NewOpt("val", {
+          descTemplate: "VoD-as-Live (make the channel a simulated live stream)",
+          type: "boolean"
+        })
+      ]
+    };
+  }
+
+  async body() {
+    const logger = this.logger;
+    const {name, items, libraryId, val} = this.args;
+    const type = await this.concerns.ArgType.typVersionHash();
+
+    const itemList = R.map(itemParser, items);
+
+    // check items
+    logger.log("\nChecking items for any parameter mismatches...");
+
+    // get items
+    const itemOfferings = [];
+    for(let i = 0; i < itemList.length; i++) {
+      const item = itemList[i];
+      const versionHash = item.hash;
+      const objectId = this.concerns.Version.objectId({versionHash});
+      const offering = await this.concerns.FabricObject.metadata({
+        libraryId,
+        objectId,
+        subtree: "/offerings/" + item.offering,
+        versionHash
+      });
+      itemOfferings.push(offering);
+    }
+
+    // make sure streams, playout formats, and ladders are the same
+    const firstPoStreams = R.map(withoutEncryptionSchemes, itemOfferings[0].playout.streams);
+    const firstPoFormats = R.map(withoutDrmContentId, itemOfferings[0].playout.playout_formats);
+    const firstMsStreamFields = msStreamFields(firstPoStreams, itemOfferings[0].media_struct.streams);
+
+    for(let i = 1; i < itemList.length; i++) {
+      const testPoStreams = R.map(withoutEncryptionSchemes, itemOfferings[i].playout.streams);
+      //
+      // console.log(JSON.stringify(firstPoStreams,null,2));
+      // console.log(JSON.stringify(testPoStreams,null,2));
+
+      if(!R.equals(firstPoStreams, testPoStreams)) throw Error("ERROR: All items must have identical playout.streams.representations");
+
+      const testPoFormats = R.map(withoutDrmContentId, itemOfferings[i].playout.playout_formats);
+      if(!R.equals(firstPoFormats, testPoFormats)) throw Error("ERROR: All items must have identical playout.playout_formats (other than widevine content_id field)");
+
+      const testMsStreamFields = msStreamFields(testPoStreams, itemOfferings[i].media_struct.streams);
+      if(!R.equals(firstMsStreamFields, testMsStreamFields)) throw Error("ERROR: All items must have matching values for included streams in the following media_struct stream fields: " + STREAM_FIELDS.join(", "));
+    }
+    // passed checks, assemble channel items metadata
+    logger.log("Mezzanine item parameter checks passed.");
+
+    // create new object
+    let metadata = {public: {name}};
+
+    logger.log("\nCreating new channel object...");
+
+    const {objectId} = await this.concerns.ArgLibraryId.libCreateObject({
+      metadata,
+      type
+    });
+
+    logger.log("\nAdding channel metadata to new object...");
+
+    // retrieve newly created object's metadata
+    metadata = await this.concerns.FabricObject.metadata({libraryId, objectId});
+
+    const channelMeta = {
+      offerings: {
+        default: {
+          items: [],
+          live_end_tol: 60,
+          live_seg_count: 60,
+          playout: {
+            playout_formats: itemOfferings[0].playout.playout_formats,
+            streams: itemOfferings[0].playout.streams
+          },
+          playout_type: (val ? "ch_val" : "ch_vod")
+        }
+      }
+    };
+
+    // add items
+    for(let i = 0; i < itemList.length; i++) {
+      const offering = itemOfferings[i];
+      const item = itemList[i];
+      const itemMeta = {
+        duration_rat: offering.media_struct.duration_rat,
+        source: {
+          ".": {
+            auto_update: {
+              tag: "latest"
+            }
+          },
+          "/": `/qfab/${item.hash}/rep/playout/${item.offering}`
+        },
+        type: "mez_vod"
+      };
+      channelMeta.offerings.default.items.push(itemMeta);
+    }
+
+    metadata.channel = channelMeta;
+    metadata.public.offerings = {"/": "./rep/channel/options.json"};
+
+
+    // Write back metadata
+    logger.log("Writing metadata...");
+    const versionHash = await this.concerns.Metadata.write({
+      libraryId,
+      metadata,
+      objectId
+    });
+
+    logger.log("");
+    logger.log(`New object ID: ${objectId}`);
+    logger.data("object_id", objectId);
+    logger.log("New version hash: " + versionHash);
+    logger.data("version_hash", versionHash);
+  }
+
+  header() {
+    return `Create channel '${this.args.name}' in lib ${this.args.libraryId}`;
+  }
+}
+
+if(require.main === module) {
+  Utility.cmdLineInvoke(ChannelCreate);
+} else {
+  module.exports = ChannelCreate;
+}

package/utilities/ChannelStartVaLOffering.js

@@ -53,6 +53,8 @@ class ChannelStartVaLOffering extends Utility {
     // ----------------------------------------------------
     const {delay, libraryId, objectId, offeringKey} = await this.concerns.ExistObj.argsProc();
 
+    const client = await this.concerns.Client.get();
+
     logger.log("Retrieving existing metadata from object...");
     const currentMetadata = await this.concerns.ExistObj.metadata();
 
@@ -83,7 +85,34 @@ class ChannelStartVaLOffering extends Utility {
       0
     );
 
-    const liveSegCount = this.args.liveWindowSize || currentMetadata.channel.offerings[offeringKey].live_seg_count || 3;
+    // get item list from channel offering, get an auth token for each to include in playout URLs
+    const mezAuthTokens = [];
+    const items = currentMetadata.channel.offerings[offeringKey].items;
+
+    const RE_URI_HASH = /\/(hq__[a-zA-Z0-9]+)\//;
+    logger.log("Generating auth tokens...");
+    for(let i = 0; i < items.length; i++) {
+      const itemURI = items[i].source["/"];
+      const mezVersionHash = RE_URI_HASH.exec(itemURI)[1];
+      if(!mezVersionHash) throw Error(`hash not found in item URI: ${itemURI}`);
+
+      const mezObjectId = this.concerns.Version.objectId({versionHash: mezVersionHash});
+      const mezLibId = await this.concerns.FabricObject.libraryId({objectId: mezObjectId});
+
+      mezAuthTokens.push(
+        await client.authClient.AuthorizationToken(
+          {
+            libraryId: mezLibId,
+            objectId: mezObjectId,
+            versionHash: mezVersionHash,
+            update: false
+          }
+        )
+      );
+    }
+
+
+    const liveSegCount = this.args.liveWindowSize || currentMetadata.channel.offerings[offeringKey].live_seg_count || 60;
     const liveEndTol = this.args.liveEndTolerance || currentMetadata.channel.offerings[offeringKey].live_end_tol || 300;
 
     const now = new Date;  // ).toISOString();
@@ -114,7 +143,6 @@ class ChannelStartVaLOffering extends Utility {
       objectId
     });
 
-    const client = await this.concerns.Client.get();
     const url = await client.FabricUrl({
       libraryId,
       objectId,
@@ -154,14 +182,15 @@ class ChannelStartVaLOffering extends Utility {
     });
 
     let offUrlObj = new URL(offeringUrl);
-    const urlBase =  offUrlObj.origin + offUrlObj.pathname;
+    const urlBase = offUrlObj.origin + offUrlObj.pathname;
     const authToken = offUrlObj.searchParams.get("authorization");
     let sid = "";
     for(const [playoutFormatKey, playoutFormatInfo] of Object.entries(offeringOptions)) {
       const pfUrlObj = new URL(playoutFormatInfo.uri, urlBase);
       sid = pfUrlObj.searchParams.get("sid");
-      const playoutUrl =  new URL(playoutFormatInfo.uri, urlBase);
+      const playoutUrl = new URL(playoutFormatInfo.uri, urlBase);
       playoutUrl.searchParams.set("authorization", authToken);
+      mezAuthTokens.forEach(t => playoutUrl.searchParams.append("authorization", t));
       playoutUrl.searchParams.set("sid", sid);
 
       logger.log();
@@ -170,37 +199,42 @@ class ChannelStartVaLOffering extends Utility {
       logger.log(playoutUrl.toString());
     }
 
-    const viewsUrl = await client.FabricUrl({
-      libraryId,
-      objectId,
-      versionHash,
-      rep: `channel/${offeringKey}/views.json`
-    });
-    const viewsUrlObj = new URL(viewsUrl);
-    viewsUrlObj.searchParams.set("sid", sid);
-    logger.log();
-    logger.log(`Sample offering '${offeringKey}' current available views URL (sid must be same as in playout URL):`);
-    logger.log();
-    logger.log(viewsUrlObj.toString());
+    const multiviewPresent = currentMetadata.channel.offerings[offeringKey].multiview &&
+      !R.empty(currentMetadata.channel.offerings[offeringKey].multiview);
+    if(multiviewPresent) {
+      const viewsUrl = await client.FabricUrl({
+        libraryId,
+        objectId,
+        versionHash,
+        rep: `channel/${offeringKey}/views.json`
+      });
+      const viewsUrlObj = new URL(viewsUrl);
+      viewsUrlObj.searchParams.set("sid", sid);
+      logger.log();
+      logger.log(`Sample offering '${offeringKey}' current available views URL (sid must be same as in playout URL):`);
+      logger.log();
+      logger.log(viewsUrlObj.toString());
 
 
-    const selectViewUrl = await client.FabricUrl({
-      libraryId,
-      objectId,
-      versionHash,
-      rep: `channel/${offeringKey}/select_view`
-    });
-    const viewSelectUrlObj = new URL(selectViewUrl);
-    viewSelectUrlObj.searchParams.set("sid", sid);
+      const selectViewUrl = await client.FabricUrl({
+        libraryId,
+        objectId,
+        versionHash,
+        rep: `channel/${offeringKey}/select_view`
+      });
+      const viewSelectUrlObj = new URL(selectViewUrl);
+      viewSelectUrlObj.searchParams.set("sid", sid);
+
+      logger.log();
+      logger.log("Sample curl command to select view (sid must be same as in playout URL):");
+      logger.log();
+      logger.log(`curl -X POST '${viewSelectUrlObj.toString()}' -d '{"view":1}'`);
+    }
 
-    logger.log();
-    logger.log("Sample curl command to select view (sid must be same as in playout URL):");
-    logger.log();
-    logger.log(`curl -X POST '${viewSelectUrlObj.toString()}' -d '{"view":1}'`);
   }
 
   header() {
-    return `Start playout of 'live' channel object ${this.args.objectId}${this.args.delay ? ` with ${this.args.delay} second(s) delay` : ""}`;
+    return `Start playout of simulated live channel object ${this.args.objectId}${this.args.delay ? ` with ${this.args.delay} second(s) delay` : ""}`;
   }
 }
 

package/utilities/LibraryListObjects.js

@@ -53,6 +53,8 @@ class LibraryListObjects extends Utility {
     const logger = this.logger;
     const filter = this.args.filter && this.concerns.JSON.parseStringOrFile({strOrPath: this.args.filter});
 
+    if(!this.args.fields) this.args.fields = [];
+
     const select = ["/public/name", ...this.args.fields];
 
     const objectList = await this.concerns.ArgLibraryId.libObjectList(

package/utilities/MezUnifyAudioDrmKeys.js

@@ -0,0 +1,69 @@
+// go through offerings and set all audio streams to use same encryption keys
+
+const R = require("ramda");
+
+const Utility = require("./lib/Utility");
+
+const ExistObj = require("./lib/concerns/ExistObj");
+const Metadata = require("./lib/concerns/Metadata");
+
+class MezUnifyAudioDrmKeys extends Utility {
+  blueprint() {
+    return {
+      concerns: [
+        ExistObj, Metadata
+      ]
+    };
+  }
+
+  async body() {
+    const logger = this.logger;
+
+    // operations that need to wait on network access
+    // ----------------------------------------------------
+    const {libraryId, objectId} = await this.concerns.ExistObj.argsProc();
+
+    logger.log("Retrieving existing metadata from object...");
+    const metadata = await this.concerns.ExistObj.metadata();
+
+    if(!metadata.offerings || R.isEmpty(metadata.offerings)) throw Error("no offerings found in metadata");
+
+    // loop through offerings
+    for(const [offeringKey, offering] of Object.entries(metadata.offerings)) {
+      logger.log(`  Checking offering ${offeringKey}...`);
+      // loop through playout streams, saving first audio stream's keys
+      let keyIds;
+      for(const [streamKey, stream] of Object.entries(offering.playout.streams)) {
+        if(stream.representations && Object.entries(stream.representations)[0][1].type === "RepAudio") {
+          if(keyIds) {
+            logger.log(`    Setting keys for stream '${streamKey}'...`);
+            stream.encryption_schemes = R.clone(keyIds);
+          } else {
+            if(!stream.encryption_schemes || R.isEmpty(stream.encryption_schemes)) throw Error(`Audio stream ${streamKey} has no encryption scheme info`);
+            logger.log(`    Using keys from stream '${streamKey}'...`);
+            keyIds = stream.encryption_schemes;
+          }
+        }
+      }
+    }
+
+    // Write back metadata
+    const newHash = await this.concerns.Metadata.write({
+      libraryId,
+      metadata,
+      objectId
+    });
+    this.logger.data("version_hash", newHash);
+    this.logger.log("New version hash: " + newHash);
+  }
+
+  header() {
+    return `Make all audio streams use same DRM keys in object ${this.args.objectId}`;
+  }
+}
+
+if(require.main === module) {
+  Utility.cmdLineInvoke(MezUnifyAudioDrmKeys);
+} else {
+  module.exports = MezUnifyAudioDrmKeys;
+}