@eluvio/elv-client-js 4.2.15 → 4.2.17

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/ChannelCreate.js

@@ -202,4 +202,4 @@ if(require.main === module) {
   Utility.cmdLineInvoke(ChannelCreate);
 } else {
   module.exports = ChannelCreate;
-}
+}

package/utilities/LibraryDownloadMp4.js

@@ -200,7 +200,20 @@ class LibraryDownloadMp4 extends Utility {
             .substring(0, 180);
     }
 
-    async processObject(e, client, libraryId, format, offering, targetDir, failedDownloads) {
+    appendFailEntry(failLogPath, entry) {
+        let entries = [];
+        if (fs.existsSync(failLogPath)) {
+            try {
+                entries = JSON.parse(fs.readFileSync(failLogPath, "utf8"));
+            } catch {
+                // If the file is malformed just start fresh
+            }
+        }
+        entries.push(entry);
+        fs.writeFileSync(failLogPath, JSON.stringify(entries, null, 2));
+    }
+
+    async processObject(e, client, libraryId, format, offering, targetDir, failedDownloads, failLogPath) {
         const objectId = e.objectId;
         const objectName = R.path(["metadata", "public", "name"], e) || objectId;
 
@@ -238,6 +251,8 @@ class LibraryDownloadMp4 extends Utility {
             // Poll job
             let status;
             let lastProgress = -1;
+            const maxPolls = 300; // 10 minutes at 2s intervals
+            let pollCount = 0;
 
             do {
                 await this.sleep(2000);
@@ -249,6 +264,16 @@ class LibraryDownloadMp4 extends Utility {
                     })
                 );
 
+                const jobStatus = status?.status;
+                if (jobStatus === "failed" || jobStatus === "error") {
+                    throw new Error(`Job ${jobId} failed with status: ${jobStatus}`);
+                }
+
+                pollCount++;
+                if (pollCount >= maxPolls) {
+                    throw new Error(`Job ${jobId} timed out after ${maxPolls} polling attempts`);
+                }
+
                 const progress = status?.progress || 0;
                 if (progress !== lastProgress) {
                     process.stdout.write(`Progress: ${progress.toFixed(1)}%\r`);
@@ -278,6 +303,11 @@ class LibraryDownloadMp4 extends Utility {
 
             formattedObj.download_url = downloadUrl;
 
+            if (fs.existsSync(outputFile)) {
+                this.logger.log(`Skipping ${objectName}: already exists (${filename})`);
+                return formattedObj;
+            }
+
             // NOW using HTTPS downloader
             this.logger.log(`Downloading → ${outputFile}`);
             await this.downloadFile(downloadUrl, outputFile);
@@ -288,12 +318,22 @@ class LibraryDownloadMp4 extends Utility {
         } catch (err) {
             this.logger.error(`FAILED: ${objectId} - ${err.message}`);
 
-            failedDownloads.push({
+            const fileServiceUrl = client.FileServiceHttpClient?.uris?.[client.FileServiceHttpClient.uriIndex] || "unknown";
+
+            const failEntry = {
                 object_id: objectId,
                 name: objectName,
                 error: err.message,
+                file_service_url: fileServiceUrl,
                 timestamp: new Date().toISOString(),
-            });
+            };
+
+            failedDownloads.push(failEntry);
+
+            if (failLogPath) {
+                this.appendFailEntry(failLogPath, failEntry);
+                this.logger.warn(`Failure recorded → ${failLogPath}`);
+            }
 
             return formattedObj;
         }
@@ -328,6 +368,13 @@ class LibraryDownloadMp4 extends Utility {
         if (!fs.existsSync(targetDir))
             fs.mkdirSync(targetDir, { recursive: true });
 
+        // Initialize fail log file with empty array at the start of the run
+        const failLogPath = this.args.failLog ? path.resolve(this.args.failLog) : null;
+        if (failLogPath) {
+            fs.writeFileSync(failLogPath, JSON.stringify([], null, 2));
+            this.logger.log(`Fail log initialized: ${failLogPath}`);
+        }
+
         // Sequential downloads
         const results = [];
         for (const obj of objectList) {
@@ -338,7 +385,8 @@ class LibraryDownloadMp4 extends Utility {
                 format,
                 offering,
                 targetDir,
-                failedDownloads
+                failedDownloads,
+                failLogPath
             );
             results.push(r);
         }
@@ -353,10 +401,8 @@ class LibraryDownloadMp4 extends Utility {
             this.logger.warn("\n=== FAILED DOWNLOADS ===");
             this.logger.logTable({ list: failedDownloads });
 
-            if (this.args.failLog) {
-                const failPath = path.resolve(this.args.failLog);
-                fs.writeFileSync(failPath, JSON.stringify(failedDownloads, null, 2));
-                this.logger.warn(`Failures written to: ${failPath}`);
+            if (failLogPath) {
+                this.logger.warn(`Full failure log: ${failLogPath}`);
             }
         }