@eluvio/elv-client-js 4.2.31 → 4.2.33

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eluvio/elv-client-js",
-  "version": "4.2.31",
+  "version": "4.2.33",
   "description": "Javascript client for the Eluvio Content Fabric",
   "main": "src/index.js",
   "author": "Kevin Talmadge",

package/src/FrameClient.js

@@ -539,6 +539,7 @@ class FrameClient {
       "StreamSaveConfigProfile",
       "StreamSetOfferingAndDRM",
       "StreamSiteSettings",
+      "StreamRestartRecording",
       "StreamStartRecording",
       "StreamStartOrStopOrReset",
       "StreamStatus",

package/src/client/LiveStream.js

@@ -197,6 +197,10 @@ const CueInfo = async ({eventId, status}) => {
  * @param {boolean=} options.linkToSite - If enabled, will create a link in the live stream site
  * @param {boolean=} options.initializeDrm - If enabled, will initialize DRM for the object
  * @param {string=} options.ingressNodeId - ID of the ingress node used for stream allocation (required for non-public nodes)
+ * @param {Object=} options.metadata - Additional metadata to merge into the live stream object metadata
+ * @param {Array<string>=} options.tags - Fabric tags to associate with the live stream
+ * @param {Array<string>=} options.groups - Fabric content group IDs to associate with the live stream. Distinct from access groups.
+ * @param {Object<string, string>=} options.queryFields - Fabric query fields to associate with the live stream
  *
  * @return {Promise<Object>} - Object containing objectId, libraryId, writeToken, and hash if finalized
  */
@@ -212,6 +216,20 @@ exports.StreamCreate = async function({
   const existingObject = !!objectId;
   let contentType;
   let adminGroups = options.accessGroups ?? [];
+  const customMetadata = options.metadata === undefined ? {} : options.metadata;
+  const {tags, groups, queryFields} = options;
+
+  if(typeof customMetadata !== "object" || Array.isArray(customMetadata)) {
+    throw Error("Stream metadata must be an object");
+  }
+
+  if(customMetadata.public !== undefined && (customMetadata.public === null || typeof customMetadata.public !== "object" || Array.isArray(customMetadata.public))) {
+    throw Error("Stream public metadata must be an object");
+  }
+
+  if(customMetadata.public?.asset_metadata !== undefined && (customMetadata.public.asset_metadata === null || typeof customMetadata.public.asset_metadata !== "object" || Array.isArray(customMetadata.public.asset_metadata))) {
+    throw Error("Stream public asset metadata must be an object");
+  }
 
   // Retrieve live stream content type
   try {
@@ -265,7 +283,10 @@ exports.StreamCreate = async function({
     editResponse = await this.CreateContentObject({
       libraryId,
       options: {
-        type: contentType
+        type: contentType,
+        tags,
+        groups,
+        queryFields
       }
     });
     objectId = editResponse.objectId;
@@ -273,14 +294,27 @@ exports.StreamCreate = async function({
 
   const {writeToken} = editResponse;
   const {
-    accessGroup,
-    name=defaultName,
     displayTitle,
     description,
     permission="editable",
     ingressNodeId,
     initializeDrm=true
   } = options;
+  const name = options.name ?? customMetadata.public?.name ?? defaultName;
+
+  if(existingObject) {
+    if(tags !== undefined) {
+      await this.SetContentObjectTags({libraryId, objectId, writeToken, tags});
+    }
+
+    if(groups !== undefined) {
+      await this.SetContentObjectGroups({libraryId, objectId, writeToken, groups});
+    }
+
+    if(queryFields !== undefined) {
+      await this.SetContentObjectQueryFields({libraryId, objectId, writeToken, queryFields});
+    }
+  }
 
   if(!liveRecordingConfig) {
     liveRecordingConfig = {};
@@ -311,10 +345,9 @@ exports.StreamCreate = async function({
     })
   );
 
-  const metadata = {
+  const generatedMetadata = {
     public: {
       name,
-      description,
       asset_metadata: {
         display_title: displayTitle || name,
         title: name || displayTitle || defaultName,
@@ -324,6 +357,22 @@ exports.StreamCreate = async function({
       }
     }
   };
+  const metadata = R.mergeDeepRight(generatedMetadata, customMetadata);
+
+  // Explicit options take precedence over custom metadata
+  metadata.public.name = name;
+  if(options.name !== undefined) {
+    metadata.public.asset_metadata.title = name;
+    metadata.public.asset_metadata.slug = slugify(name);
+  }
+
+  if(displayTitle !== undefined) {
+    metadata.public.asset_metadata.display_title = displayTitle;
+  }
+
+  if(description !== undefined) {
+    metadata.public.description = description;
+  }
 
   const currentLiveRecordingConfig = await this.ContentObjectMetadata({
     libraryId,
@@ -1286,6 +1335,117 @@ exports.StreamStartRecording = async function({name, start=false}) {
   return status;
 };
 
+/**
+ * Stop the current live recording and start a new one with a new edge write token.
+ * The main object is finalized only once.
+ *
+ * @methodGroup Live Stream
+ * @namedParams
+ * @param {string} name - Object ID or name of the live stream object
+ *
+ * @return {Promise<Object>} - The status response for the new recording session
+ */
+exports.StreamRestartRecording = async function({name}) {
+  let status = await this.StreamStatus({name});
+  const oldEdgeWriteToken = status?.edgeWriteToken;
+
+  if(!oldEdgeWriteToken) {
+    throw new Error("Unable to restart stream - no active recording session");
+  }
+
+  if(["running", "starting", "stalled"].includes(status.state)) {
+    status = await this.StreamStartOrStopOrReset({name, op: "stop"});
+  }
+
+  const IsStopped = currentStatus =>
+    currentStatus?.state === "stopped" &&
+    !currentStatus.error &&
+    currentStatus.edgeWriteToken === oldEdgeWriteToken;
+
+  if(!IsStopped(status)) {
+    throw new Error(`Unable to restart stream - current LRO did not stop definitively (state: ${status?.state || "unknown"})`);
+  }
+
+  const {libraryId, objectId, fabricApi} = status;
+  if(!fabricApi) {
+    throw new Error("Unable to restart stream - ingress node API is unavailable");
+  }
+
+  this.SetNodes({fabricURIs: [fabricApi]});
+
+  let mainWriteToken;
+  let newEdgeWriteToken;
+  let mainObjectFinalizeStarted = false;
+
+  try {
+    ({writeToken: mainWriteToken} = await this.EditContentObject({
+      libraryId,
+      objectId
+    }));
+
+    ({writeToken: newEdgeWriteToken} = await this.EditContentObject({
+      libraryId,
+      objectId
+    }));
+
+    await this.MergeMetadata({
+      libraryId,
+      objectId,
+      writeToken: mainWriteToken,
+      metadata: {
+        live_recording: {
+          status: {
+            edge_write_token: newEdgeWriteToken,
+            state: "active"
+          },
+          fabric_config: {
+            edge_write_token: newEdgeWriteToken
+          }
+        }
+      }
+    });
+
+    // Verify the old LRO is definitively stopped before publishing and deleting the old token.
+    status = await this.StreamStatus({name});
+    if(!IsStopped(status)) {
+      throw new Error(`Unable to restart stream - current LRO stop could not be confirmed (state: ${status?.state || "unknown"})`);
+    }
+    mainObjectFinalizeStarted = true;
+    const finalizeResponse = await this.FinalizeContentObject({
+      libraryId,
+      objectId,
+      writeToken: mainWriteToken,
+      commitMessage: `Restart stream with edge write token ${newEdgeWriteToken}`
+    });
+
+    try {
+      await this.DeleteWriteToken({writeToken: oldEdgeWriteToken});
+    } catch(error) {
+      this.Log(`Unable to delete old edge write token ${oldEdgeWriteToken}: ${error.message}`, true);
+    }
+
+    const restartedStatus = await this.StreamStartOrStopOrReset({name, op: "start"});
+    return {
+      ...restartedStatus,
+      hash: finalizeResponse.hash
+    };
+  } catch(error) {
+    // Before main-object finalization begins, both new drafts are safe to discard and the old
+    // stopped recording remains referenced by the published object.
+    if(!mainObjectFinalizeStarted) {
+      for(const writeToken of [newEdgeWriteToken, mainWriteToken].filter(Boolean)) {
+        try {
+          await this.DeleteWriteToken({writeToken});
+        } catch(cleanupError) {
+          this.Log(`Unable to clean up restart write token ${writeToken}: ${cleanupError.message}`, true);
+        }
+      }
+    }
+
+    throw error;
+  }
+};
+
 /**
  * Start, stop or reset a stream within the current session (current edge write token)
  *