@eluvio/elv-client-js 4.2.16 → 4.2.18

package/src/client/NTP.js

@@ -253,6 +253,51 @@ exports.DeleteNTPInstance = async function({tenantId, ntpId}) {
   });
 };
 
+/**
+ * Generate a report for the specified NTP instance.
+ *
+ * @methodGroup NTP Instances
+ * @namedParams
+ * @param {string} tenantId - The ID of the tenant in which this NTP instance was created
+ * @param {string} ntpId - The ID of the NTP instance
+ * @param {string} password - The code associated with the NTP instance
+ * @param {string=} email - Email address associated with the code
+ */
+exports.ReportNTPInstance = async function({tenantId, ntpId, password, email}) {
+  ValidatePresence("tenantId", tenantId);
+  ValidatePresence("ntpId", ntpId);
+
+  let paramsJSON = [];
+
+  if (password) {
+    paramsJSON.push(`pwd:${password}`);
+  }
+
+  if (email) {
+    paramsJSON.push(`eml:${email}`);
+  }
+
+  const res = await this.authClient.MakeKMSCall({
+    tenantId,
+    methodName: "elv_updateOTPInstance",
+    params: [
+      tenantId,
+      ntpId,
+      "report",
+      JSON.stringify(paramsJSON),
+      Date.now()
+    ],
+    paramTypes: [
+      "string",
+      "string",
+      "string",
+      "string",
+      "int"
+    ]
+  });
+  return res || {};
+};
+
 /**
  * Retrieve info for NTP instances in the specified tenant
  *
@@ -389,6 +434,32 @@ exports.IssueSignedNTPCode = async function({tenantId, ntpId, email, maxRedempti
   return result;
 };
 
+/**
+ * Check the status of the specified ticket/code without redeeming it.
+ *
+ * @methodGroup Tickets
+ * @namedParams
+ * @param {string} tenantId - The ID of the tenant from which the ticket was issued
+ * @param {string} ntpId - The ID of the NTP instance from which the ticket was issued
+ * @param {string} code - Access code
+ * @param {string=} email - Email address associated with the code
+ *
+ * @return {Promise<Object>} - Status information for the ticket
+ */
+exports.NTPStatus = async function({tenantId, ntpId, code, email}) {
+  ValidatePresence("tenantId", tenantId);
+  ValidatePresence("ntpId", ntpId);
+  ValidatePresence("code", code);
+
+  const response = await this.HttpClient.Request({
+    method: "POST",
+    path: UrlJoin("ks", "otp", "ntp", tenantId, ntpId, "status"),
+    body: {"_PASSWORD": code, "_EMAIL": email}
+  });
+
+  return await response.json();
+};
+
 /**
  * Redeem the specified ticket/code to authorize the client. Must provide either issuer or tenantId and ntpId
  *

package/src/live_recording_config_profiles/live_recording_config_default.js

@@ -0,0 +1,54 @@
+const LiveRecordingConfigDefault = {
+  drm_type: "clear",
+  recording_config: {
+    part_ttl: 86400,
+    reconnect_timeout: 3600,
+    connection_timeout: 3600,
+    copy_mpegts: false,
+  },
+  profile: {
+    ladder_specs: {
+      audio: [
+        {
+          bit_rate: 192000,
+          channels: 2,
+          codecs: "mp4a.40.2"
+        },
+        {
+          bit_rate: 384000,
+          channels: 6,
+          codecs: "mp4a.40.2"
+        }
+      ],
+      video: [
+        {
+          bit_rate: 9500000,
+          codecs: "avc1.640028,mp4a.40.2",
+          height: 1080,
+          width: 1920
+        },
+        {
+          bit_rate: 4500000,
+          codecs: "avc1.640028,mp4a.40.2",
+          height: 720,
+          width: 1280
+        },
+        {
+          bit_rate: 2000000,
+          codecs: "avc1.640028,mp4a.40.2",
+          height: 540,
+          width: 960
+        },
+        {
+          bit_rate: 900000,
+          codecs: "avc1.640028,mp4a.40.2",
+          height: 540,
+          width: 960
+        }
+      ]
+    },
+    name: "Default"
+  }
+}
+
+module.exports = LiveRecordingConfigDefault;

package/src/live_recording_config_profiles/live_stream_profile_full.json

@@ -0,0 +1,143 @@
+{
+  "name": "Reference Full Profile",
+  "drm_type": "clear",
+
+  "recording_config": {
+    "part_ttl": 86400,
+    "reconnect_timeout": 3600,
+    "connection_timeout": 3600,
+    "copy_mpegts": false,
+    "input_cfg": {
+      "bypass_libav_reader": false,
+      "copy_mode": "",
+      "copy_packaging": "",
+      "custom_read_loop_enabled": false,
+      "input_packaging": ""
+    }
+  },
+
+  "playout_config": {
+    "dvr_enabled": true,
+    "dvr_max_duration": 14400,
+    "rebroadcast_start_time_sec_epoch": 0,
+    "playout_sharding_level": 2,
+    "vod_enabled": false,
+    "playout_formats": [
+      "hls-clear"
+    ],
+    "ladder_specs": {
+      "audio": [
+        {
+          "bit_rate": 192000,
+          "channels": 2,
+          "codecs": "mp4a.40.2"
+        },
+        {
+          "bit_rate": 384000,
+          "channels": 6,
+          "codecs": "mp4a.40.2"
+        }
+      ],
+      "video": [
+        {
+          "bit_rate": 14000000,
+          "codecs": "avc1.640028,mp4a.40.2",
+          "height": 2160,
+          "width": 3840
+        },
+        {
+          "bit_rate": 9500000,
+          "codecs": "avc1.640028,mp4a.40.2",
+          "height": 1080,
+          "width": 1920
+        },
+        {
+          "bit_rate": 4500000,
+          "codecs": "avc1.640028,mp4a.40.2",
+          "height": 720,
+          "width": 1280
+        },
+        {
+          "bit_rate": 2000000,
+          "codecs": "avc1.640028,mp4a.40.2",
+          "height": 540,
+          "width": 960
+        },
+        {
+          "bit_rate": 900000,
+          "codecs": "avc1.640028,mp4a.40.2",
+          "height": 540,
+          "width": 960
+        }
+      ]
+    },
+    "simple_watermark": {
+      "font_color": "white@0.5",
+      "font_relative_height": 0.05,
+      "shadow": true,
+      "shadow_color": "black@0.5",
+      "template": "",
+      "x": "(w-tw)/2",
+      "y": "h-(4*lh)"
+    },
+    "image_watermark": {
+      "align_h": "right",
+      "align_v": "bottom",
+      "image": "",
+      "margin_h": "1/20",
+      "margin_v": "1/10",
+      "target_video_height": 1080,
+      "wm_enabled": false
+    }
+  },
+
+  "recording_stream_config": {
+    "audio": {
+      "0": {
+        "bitrate": 192000,
+        "codec": "aac",
+        "playout": true,
+        "playout_label": "Audio 1",
+        "record": true,
+        "recording_bitrate": 192000,
+        "recording_channels": 2,
+        "lang": ""
+      }
+    }
+  },
+
+  "recording_params": {
+    "description": "",
+    "listen": true,
+    "live_delay_nano": 6000000000,
+    "max_duration_sec": -1,
+    "playout_type": "live",
+    "source_timescale": null,
+    "xc_params": {
+      "audio_bitrate": 384000,
+      "audio_index": [0, 0, 0, 0, 0, 0, 0, 0],
+      "audio_seg_duration_ts": null,
+      "connection_timeout": 600,
+      "ecodec2": "aac",
+      "enc_height": null,
+      "enc_width": null,
+      "filter_descriptor": "",
+      "force_keyint": null,
+      "format": "fmp4-segment",
+      "listen": true,
+      "n_audio": 1,
+      "preset": "faster",
+      "sample_rate": 48000,
+      "seg_duration": null,
+      "skip_decoding": false,
+      "start_segment_str": "1",
+      "stream_id": -1,
+      "sync_audio_to_stream_id": -1,
+      "video_bitrate": null,
+      "video_seg_duration_ts": null,
+      "video_time_base": null,
+      "video_frame_duration_ts": null,
+      "xc_type": 3
+    }
+  }
+}

package/testScripts/StreamUpdateLinks.js

@@ -0,0 +1,95 @@
+const { ElvClient } = require("../src/index");
+
+const Test = async () => {
+  try {
+    const client = await ElvClient.FromNetworkName({
+      networkName: "demo"
+    });
+
+    const wallet = client.GenerateWallet();
+    const signer = wallet.AddAccount({
+      privateKey: process.env.PRIVATE_KEY
+    });
+
+    client.SetSigner({signer});
+
+    CreateLink = ({
+      targetHash,
+      linkTarget="meta/public/asset_metadata",
+      options={},
+      autoUpdate=true
+    }) => {
+      return {
+        ...options,
+        ".": {
+          ...(options["."] || {}),
+          ...autoUpdate ? {"auto_update": {"tag": "latest"}} : undefined
+        },
+        "/": `/qfab/${targetHash}/${linkTarget}`
+      };
+    };
+
+    UpdateStreamLink = async ({siteLibraryId, siteId, objectId, slug}) => {
+      try {
+        const originalLink = await client.ContentObjectMetadata({
+          libraryId: siteLibraryId,
+          objectId: siteId,
+          metadataSubtree: `public/asset_metadata/live_streams/${slug}`,
+        });
+
+        const link = CreateLink({
+          targetHash: await client.LatestVersionHash({objectId}),
+          options: {order: originalLink.order}
+        });
+
+        await client.ReplaceMetadata({
+          libraryId: siteLibraryId,
+          objectId: siteId,
+          writeToken,
+          metadataSubtree: `public/asset_metadata/live_streams/${slug}`,
+          metadata: link
+        });
+      } catch(error) {
+        // eslint-disable-next-line no-console
+        console.error("Unable to update stream link", error);
+      }
+    }
+
+    const {streamMetadata, siteObjectId, siteLibraryId} = await client.StreamGetSiteData({streamOptions: {resolveIncludeSource: false, resolveLinks: false}});
+
+    const {writeToken} = await client.EditContentObject({
+      libraryId: siteLibraryId,
+      objectId: siteObjectId
+    });
+
+    for(let streamSlug in streamMetadata) {
+      const obj = streamMetadata[streamSlug];
+
+      const versionHash = obj["/"] ? obj["/"].split("/")[2] : obj["."].source;
+      const objId = client.utils.DecodeVersionHash(versionHash).objectId;
+
+      await UpdateStreamLink({
+        siteLibraryId,
+        objectId: objId,
+        siteId: siteObjectId,
+        slug: streamSlug
+      });
+    }
+
+    await client.FinalizeContentObject({
+      libraryId: siteLibraryId,
+      objectId: siteObjectId,
+      writeToken,
+      commitMessage: "Update stream link",
+      awaitCommitConfirmation: true
+    });
+
+  } catch(error) {
+    console.error(error);
+    console.error(JSON.stringify(error, null, 2));
+  }
+
+  process.exit(0);
+};
+
+Test();

package/utilities/LiveOutputs.js

@@ -0,0 +1,149 @@
+/**
+ * LiveOutputs.js - Manage live outputs
+ *
+ * Usage:
+ *   PRIVATE_KEY=<key> node utilities/LiveOutputs.js <command> [options]
+ *
+ * Commands:
+ *   list                                                   List all outputs with config and state
+ *   status  <output_id>                                    Show config and live state for an output
+ *   create  --stream <id> [--node <id> | --geo <geo>]      Create a new output
+ *           [--passphrase <pass>] [--name <name>]
+ *   modify  <output_id> [--stream <id>] [--enable true|false]  Modify an existing output
+ *           [--passphrase <pass>] [--name <name>]
+ *   delete  <output_id>                                    Delete an output
+ *
+ * Examples:
+ *   node utilities/LiveOutputs.js list
+ *   node utilities/LiveOutputs.js status out005
+ *   node utilities/LiveOutputs.js create --stream iq__abc123 --node inod123 --name "My Output"
+ *   node utilities/LiveOutputs.js create --stream iq__abc123 --geo na-west-north
+ *   node utilities/LiveOutputs.js modify out005 --enable false
+ *   node utilities/LiveOutputs.js modify out005 --stream iq_def456 --passphrase "new-secret" --name "Renamed"
+ *   node utilities/LiveOutputs.js delete out005
+ */
+const { ElvClient } = require("../src/ElvClient");
+
+const OBJECT_ID = "iq__eiDtwuBbAfyJCQqFKS5drdeDToL";  // demov3
+
+const Init = async () => {
+  const client = await ElvClient.FromNetworkName({networkName: "demov3"});
+  const wallet = client.GenerateWallet();
+  const signer = wallet.AddAccount({privateKey: process.env.PRIVATE_KEY});
+  client.SetSigner({signer});
+  client.ToggleLogging(false);
+  return client;
+};
+
+const List = async () => {
+  const client = await Init();
+  const outputs = await client.OutputsList({objectId: OBJECT_ID, includeState: true});
+  console.log(JSON.stringify(outputs, null, 2));
+};
+
+const Status = async (outputId) => {
+  const client = await Init();
+  const state = await client.OutputsState({objectId: OBJECT_ID, outputId, includeState: true});
+  console.log(JSON.stringify(state, null, 2));
+};
+
+const Create = async ({streamId, nodeId, geo, passphrase, name}) => {
+  const client = await Init();
+  const result = await client.OutputsCreate({
+    objectId: OBJECT_ID,
+    streamObjectId: streamId,
+    enabled: true,
+    name,
+    nodeIds: nodeId ? [nodeId] : undefined,
+    geos: geo ? [geo] : [],
+    passphrase,
+    stripRtp: true
+  });
+  console.log(JSON.stringify(result, null, 2));
+};
+
+const Modify = async (outputId, {streamId, enable, passphrase, name}) => {
+  const client = await Init();
+
+  // Read current output to use as base
+  let output = await client.OutputsState({objectId: OBJECT_ID, outputId, includeState: false})
+
+  if(streamId !== undefined) {
+    output.input = {stream: streamId};
+  }
+  if(enable !== undefined) {
+    output.enabled = enable;
+  }
+  if(passphrase !== undefined) {
+    output.srt_pull = output.srt_pull || {};
+    output.srt_pull.passphrase = passphrase;
+  }
+  if(name !== undefined) {
+    output.name = name;
+  }
+
+  const result = await client.OutputsModify({objectId: OBJECT_ID, outputId, output});
+  console.log(JSON.stringify(result, null, 2));
+};
+
+const Delete = async (outputId) => {
+  const client = await Init();
+  const result = await client.OutputsDelete({objectId: OBJECT_ID, outputId});
+  console.log(JSON.stringify(result, null, 2));
+};
+
+const Run = async (fn) => {
+  try {
+    await fn();
+  } catch(error) {
+    if(error.status) {
+      console.error(`${error.status} ${error.statusText} ${error.url || ""}`);
+      if(error.body) {
+        console.error(JSON.stringify(error.body, null, 2));
+      }
+    } else {
+      console.error(error.message || error);
+    }
+    process.exit(1);
+  }
+};
+
+const getArg = (args, flag) => args.includes(flag) ? args[args.indexOf(flag) + 1] : undefined;
+
+const [cmd, ...args] = process.argv.slice(2);
+
+switch(cmd) {
+  case "list":
+    Run(List);
+    break;
+  case "status":
+    Run(() => Status(args[0]));
+    break;
+  case "create":
+    Run(() => Create({
+      streamId: getArg(args, "--stream"),
+      nodeId: getArg(args, "--node"),
+      geo: getArg(args, "--geo"),
+      passphrase: getArg(args, "--passphrase"),
+      name: getArg(args, "--name")
+    }));
+    break;
+  case "modify":
+    Run(() => Modify(args[0], {
+      streamId: getArg(args, "--stream"),
+      enable: args.includes("--enable") ? getArg(args, "--enable") === "true" : undefined,
+      passphrase: getArg(args, "--passphrase"),
+      name: getArg(args, "--name")
+    }));
+    break;
+  case "delete":
+    Run(() => Delete(args[0]));
+    break;
+  default:
+    console.log("Usage: PRIVATE_KEY=<key> node utilities/LiveOutputs.js <command>\n");
+    console.log("  list");
+    console.log("  status   <output_id>");
+    console.log("  create   --stream <stream_object_id> [--node <node_id> | --geo <geo>] [--passphrase <pass>] [--name <name>]");
+    console.log("  modify   <output_id> [--stream <stream_object_id>] [--enable true|false] [--passphrase <pass>] [--name <name>]");
+    console.log("  delete   <output_id>");
+}

package/utilities/StreamCreate.js

@@ -0,0 +1,53 @@
+const Client = require("./lib/concerns/Client");
+const {NewOpt, StdOpt} = require("./lib/options");
+const Library = require("./lib/concerns/Library");
+const Utility = require("./lib/Utility");
+
+class StreamCreate extends Utility {
+  blueprint() {
+    return {
+      concerns: [Client],
+      options: [
+        StdOpt(
+          "libraryId",
+          {
+            demand: true,
+            forX: "new stream"
+          }
+        ),
+        NewOpt(
+          "url",
+          {
+            demand: true,
+            descTemplate: "URL{X}",
+            type: "string"
+          }
+        )
+      ]
+    };
+  }
+
+  async body() {
+    const logger = this.logger;
+    const {libraryId, url} = this.args;
+
+    const client = await this.concerns.Client.get();
+    const response = await client.StreamCreate({
+      libraryId,
+      url
+    });
+
+    logger.log(`New object ID: ${response.id}`);
+    logger.data("object_id", response.id);
+  }
+
+  header() {
+    return `Create live stream '${this.args.libraryId}':`;
+  }
+}
+
+if(require.main === module) {
+  Utility.cmdLineInvoke(StreamCreate);
+} else {
+  module.exports = StreamCreate;
+}

package/utilities/lib/helpers.js

@@ -77,6 +77,9 @@ const suppressNullLike = x => kindOf(x) === "null" || kindOf(x) === "undefined"
 
 const trimSlashes = R.compose(removeLeadingSlash, removeTrailingSlash);
 
+const slugify = str =>
+  (str || "").toLowerCase().trim().replace(/ /g, "-").replace(/[^a-z0-9-]/g, "");
+
 // --------------------------------------------
 // time formatting
 // --------------------------------------------
@@ -225,6 +228,7 @@ module.exports = {
   removeTrailingSlash,
   seconds,
   singleEntryMap,
+  slugify,
   spaceAfter,
   stringOrFileContents,
   subst,
@@ -235,4 +239,4 @@ module.exports = {
   unit,
   valOrThrow,
   widthForRatioAndHeight
-};
+};

package/utilities/tests/mocks/ElvClient.mock.js

@@ -307,6 +307,13 @@ const StartABRMezzanineJobs = async (args) => {
   };
 };
 
+const StreamCreate = async (args) => {
+  calls.push("StreamCreate: " + JSON.stringify(args));
+  return {
+    id: "iq__dummy_new_id"
+  };
+};
+
 const UploadFiles = async (args) => {
   calls.push("UploadFiles: " + JSON.stringify(args));
 };
@@ -332,6 +339,7 @@ const MockClient = {
   ReplaceMetadata,
   SetVisibility,
   StartABRMezzanineJobs,
+  StreamCreate,
   UploadFiles
 };
 
@@ -503,4 +511,4 @@ const writeTokens = {};
 
 
 
-module.exports = {removeStubs, stubClient};
+module.exports = {removeStubs, stubClient};

package/utilities/tests/unit/StreamCreate.test.js

@@ -0,0 +1,39 @@
+const chai = require("chai");
+const chaiAsPromised = require("chai-as-promised");
+const expect = chai.expect;
+chai.use(chaiAsPromised);
+
+const {removeStubs, stubClient} = require("../mocks/ElvClient.mock");
+const {argList2Params, removeElvEnvVars} = require("../helpers/params");
+
+removeElvEnvVars();
+beforeEach(removeStubs);
+
+const StreamCreate = require("../../StreamCreate");
+
+describe("StreamCreate", () => {
+  it("should complain if --libraryId not supplied", () => {
+    expect(() => {
+      new StreamCreate(argList2Params("--url", "http://example.com"));
+    }).to.throw("Missing required argument: libraryId");
+  });
+
+  it("should complain if --url not supplied", () => {
+    expect(() => {
+      new StreamCreate(argList2Params("--libraryId", "ilib123"));
+    }).to.throw("Missing required argument: url");
+  });
+
+  it("should call StreamCreate() and include object_id in return value", () => {
+    const utility = new StreamCreate(argList2Params("--libraryId", "ilib123", "--url", "http://example.com", "--json"));
+    const stub = stubClient(utility.concerns.Client);
+    stub.resetHistory();
+    return utility.run().then( (retVal) => {
+      expect(retVal.object_id).to.equal("iq__dummy_new_id");
+
+      expect(stub.callHistoryMismatches([
+        "StreamCreate"
+      ]).length).to.equal(0);
+    });
+  });
+});