@norskvideo/norsk-studio-built-ins 1.18.0 → 1.26.0-2025-02-19-33cde15d

package/lib/output.autoCmaf/runtime.js

@@ -1,4 +1,7 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AutoCmaf = void 0;
 const norsk_sdk_1 = require("@norskvideo/norsk-sdk");
@@ -8,16 +11,112 @@ const logging_1 = require("@norskvideo/norsk-studio/lib/server/logging");
 const ezdrm_1 = require("../shared/drm/ezdrm");
 const axinom_1 = require("../shared/drm/axinom");
 const util_2 = require("@norskvideo/norsk-studio/lib/runtime/util");
+const promises_1 = __importDefault(require("fs/promises"));
+const json_refs_1 = require("json-refs");
+const path_1 = __importDefault(require("path"));
+const yaml_1 = __importDefault(require("yaml"));
+function coreInfo(path, op) {
+    return {
+        url: path,
+        summary: op.summary,
+        description: op.description,
+        requestBody: op.requestBody,
+        responses: op.responses,
+    };
+}
+function post(path, paths) {
+    return {
+        ...coreInfo(path, paths[path]['post']),
+        method: 'POST',
+    };
+}
 class AutoCmafDefinition {
-    async create(norsk, cfg, cb, { updates, report }) {
-        const node = await AutoCmaf.create(norsk, cfg, report);
+    async create(norsk, cfg, cb, runtime) {
+        return this.createImpl(norsk, { mode: 'cmaf', ...cfg }, cb, runtime);
+    }
+    async createImpl(norsk, cfg, cb, runtime) {
+        const node = await AutoCmaf.create(norsk, cfg, runtime);
         cb(node);
-        const mv = node.mv;
-        if (mv) {
-            report.registerOutput(cfg.id, mv.url);
-            updates.raiseEvent({ type: 'url-published', url: mv.url, drmToken: node.crypto?.token });
+    }
+    async handleCommand(node, command) {
+        switch (command.type) {
+            case 'enable-output':
+                await node.enableOutput();
+                break;
+            case 'disable-output':
+                await node.disableOutput();
+                break;
+            default:
+                (0, util_1.assertUnreachable)(command.type);
         }
     }
+    async instanceRoutes() {
+        const types = await promises_1.default.readFile(path_1.default.join(__dirname, 'types.yaml'));
+        const root = yaml_1.default.parse(types.toString());
+        const resolved = await (0, json_refs_1.resolveRefs)(root, {}).then((r) => r.resolved);
+        const paths = resolved.paths;
+        function waitFor(condition, finish) {
+            if (condition()) {
+                return finish();
+            }
+            setTimeout(() => {
+                waitFor(condition, finish);
+            }, 10);
+        }
+        return [
+            {
+                ...post('/enable', paths),
+                handler: ({ runtime }) => async (_req, res) => {
+                    try {
+                        const state = runtime.updates.latest();
+                        if (state.enabled) {
+                            return res.status(400).json({ error: 'Output is already enabled' });
+                        }
+                        runtime.updates.sendCommand({
+                            type: 'enable-output'
+                        });
+                        waitFor(() => runtime.updates.latest().enabled, () => {
+                            res.sendStatus(204);
+                        });
+                    }
+                    catch (error) {
+                        console.error('Error in enable handler:', error);
+                        res.status(500).json({ error: 'Failed to enable output' });
+                    }
+                }
+            },
+            {
+                ...post('/disable', paths),
+                handler: ({ runtime }) => async (_req, res) => {
+                    try {
+                        const state = runtime.updates.latest();
+                        if (!state.enabled) {
+                            return res.status(400).json({ error: 'Output is already disabled' });
+                        }
+                        runtime.updates.sendCommand({
+                            type: 'disable-output'
+                        });
+                        waitFor(() => !runtime.updates.latest().enabled, () => {
+                            res.sendStatus(204);
+                        });
+                    }
+                    catch (error) {
+                        console.error('Error in disable handler:', error);
+                        res.status(500).json({ error: 'Failed to disable output' });
+                    }
+                }
+            }
+        ];
+    }
+    async schemas() {
+        const types = await promises_1.default.readFile(path_1.default.join(__dirname, 'types.yaml'));
+        const root = yaml_1.default.parse(types.toString());
+        const resolved = await (0, json_refs_1.resolveRefs)(root, {}).then((r) => r.resolved);
+        return {
+            config: resolved.components.schemas['AutoCmafConfig'],
+            state: resolved.components.schemas['CmafOutputState']
+        };
+    }
 }
 exports.default = AutoCmafDefinition;
 class AutoCmaf extends base_nodes_1.CustomSinkNode {
@@ -26,27 +125,31 @@ class AutoCmaf extends base_nodes_1.CustomSinkNode {
     currentSources = new Map();
     currentMedia = [];
     crypto;
+    control = new util_2.ContextPromiseControl(this.handleContext.bind(this));
     mv;
     defaultProgramNumber = 0;
     defaultSourceName = '';
-    control = new util_2.ContextPromiseControl(this.handleContext.bind(this));
     currentMultiVariants = [];
-    pendingResponses = [];
     initialised;
     sessionId;
     destinations;
     advertDestinations = [];
-    report;
-    static async create(norsk, cfg, report) {
-        const node = new AutoCmaf(cfg, norsk, report);
+    runtime;
+    enabled = true;
+    static async create(norsk, cfg, runtime) {
+        const node = new AutoCmaf(cfg, norsk, runtime);
         await node.initialised;
         return node;
     }
-    constructor(cfg, norsk, report) {
+    constructor(cfg, norsk, runtime) {
         super(cfg.id);
         this.cfg = cfg;
         this.norsk = norsk;
-        this.report = report;
+        this.runtime = runtime;
+        this.enabled = cfg.initialState == 'enabled';
+        if (!this.enabled) {
+            runtime.updates.raiseEvent({ type: 'output-disabled' });
+        }
         if (this.cfg.sessionId) {
             this.sessionId = (Math.random() + 1).toString(36).substring(7);
         }
@@ -58,9 +161,9 @@ class AutoCmaf extends base_nodes_1.CustomSinkNode {
             holdBackSeconds: (cfg.segments.holdBackSegments ?? 3) * cfg.segments.targetSegmentDuration,
             partHoldBackSeconds: (cfg.segments.holdBackParts ?? 3) * cfg.segments.targetPartDuration,
             sessionId: this.sessionId,
-            id: 'local'
+            id: `local-${this.id}`
         });
-        cfg.s3Destinations.forEach((d, i) => {
+        cfg.destinations.filter((d) => d.type == 's3').forEach((d, i) => {
             let sanitisedPrefix = d.prefix;
             if (sanitisedPrefix == "") {
                 sanitisedPrefix = "/";
@@ -71,7 +174,7 @@ class AutoCmaf extends base_nodes_1.CustomSinkNode {
                 if (!sanitisedPrefix.endsWith("/"))
                     sanitisedPrefix = sanitisedPrefix + "/";
             }
-            const id = `s3-${i}`;
+            const id = `s3-${i}-${this.id}`;
             this.destinations.push({
                 id,
                 type: 's3',
@@ -88,6 +191,22 @@ class AutoCmaf extends base_nodes_1.CustomSinkNode {
                 this.advertDestinations.push(id);
             }
         });
+        cfg.destinations.filter((d) => d.type == 'akamai').forEach((d, i) => {
+            const id = `akamai-${i}-${this.id}`;
+            const url = new URL(d.ingest);
+            this.destinations.push({
+                id,
+                type: 'generic',
+                host: url.host,
+                port: url.port ? parseInt(url.port, 10) : 80,
+                pathPrefix: url.pathname.endsWith("/") ? url.pathname : `${url.pathname}/`,
+                retentionPeriodSeconds: cfg.segments.retentionPeriod,
+            });
+            if (d.includeAdInsertions) {
+                this.advertDestinations.push(id);
+            }
+        });
+        this.advertDestinations.push('local');
         this.initialised = this.initialise();
     }
     async initialise() {
@@ -106,16 +225,55 @@ class AutoCmaf extends base_nodes_1.CustomSinkNode {
             ].join("\n"),
             mpdAdditions: "",
         } : {};
-        const mv = await this.norsk.output.cmafMultiVariant({
-            id: `${this.cfg.id}-multivariant`,
-            playlistName: this.cfg.name,
-            destinations: this.destinations,
-            ...mvCryptoSettings,
-        });
-        this.setup({ sink: mv });
-        this.mv = mv;
+        if (this.cfg.mode == 'cmaf') {
+            const cmaf = await this.norsk.output.cmafMultiVariant({
+                id: `${this.cfg.id}-multivariant-cmaf`,
+                playlistName: this.cfg.name,
+                destinations: this.destinations,
+                ...mvCryptoSettings,
+            });
+            this.setup({ sink: cmaf });
+            this.mv = cmaf;
+        }
+        else {
+            const ts = await this.norsk.output.hlsTsMultiVariant({
+                id: `${this.cfg.id}-multivariant-ts`,
+                playlistName: this.cfg.name,
+                destinations: this.destinations,
+                ...mvCryptoSettings,
+            });
+            this.setup({ sink: ts });
+            this.mv = ts;
+        }
+        this.runtime.report.registerOutput(this.cfg.id, this.mv.url);
+        this.runtime.updates.raiseEvent({ type: 'url-published', url: this.mv.url, drmToken: this.crypto?.token });
+    }
+    async enableOutput() {
+        if (!this.enabled) {
+            (0, logging_1.debuglog)("Enabling output", { id: this.id });
+            this.enabled = true;
+            await this.control.schedule();
+            this.runtime.updates.raiseEvent({ type: 'output-enabled' });
+            (0, logging_1.debuglog)("Output enabled", { id: this.id });
+        }
+    }
+    async disableOutput() {
+        if (this.enabled) {
+            (0, logging_1.debuglog)("Disabling output", { id: this.id });
+            this.enabled = false;
+            for (const media of this.currentMedia) {
+                await media.node?.close();
+            }
+            this.runtime.updates.raiseEvent({ type: 'output-disabled' });
+            this.currentMedia = [];
+            (0, logging_1.debuglog)("output disabled", { id: this.id });
+        }
     }
     async handleContext() {
+        if (!this.enabled) {
+            (0, logging_1.debuglog)("Skipping context handling - output disabled", { id: this.id });
+            return;
+        }
         const streams = [];
         this.currentSources.forEach((subscription) => {
             for (const stream of subscription.latestStreams()) {
@@ -131,32 +289,41 @@ class AutoCmaf extends base_nodes_1.CustomSinkNode {
             const existing = this.currentMedia.find((e) => (0, norsk_sdk_1.streamKeysAreEqual)(e.key, stream.key));
             if (existing)
                 return;
-            const newMedia = {
-                key: stream.key,
-                node: undefined,
-                scheduleAd: (_ad, _destinationId) => { }
-            };
-            this.currentMedia.push(newMedia);
+            (0, logging_1.debuglog)("Handling new stream in AutoCMAF", { id: this.id, streamKey: stream.key });
             if (this.currentMultiVariants.length == 0) {
+                (0, logging_1.debuglog)("Setting default multi-variant in AutoCMAF", { id: this.id, streamKey: stream.key });
                 this.defaultProgramNumber = stream.key.programNumber;
                 this.defaultSourceName = stream.key.sourceName;
             }
-            if (!this.currentMultiVariants.find((v) => v.programNumber == stream.key.programNumber && v.sourceName == stream.key.sourceName)) {
-                const newMv = {
-                    programNumber: stream.key.programNumber,
-                    sourceName: stream.key.sourceName,
-                    node: undefined
-                };
-                this.currentMultiVariants.push(newMv);
-                const mv = await this.norsk.output.cmafMultiVariant({
-                    id: `${this.cfg.id}-multivariant-${stream.key.sourceName}-${stream.key.programNumber}`,
-                    playlistName: `${this.cfg.name}-${stream.key.sourceName}-${stream.key.programNumber}`,
-                    destinations: this.destinations
-                });
-                newMv.node = mv;
-                this.report.registerOutput(this.cfg.id, mv.url);
+            if (this.cfg.multiplePrograms) {
+                if (!this.currentMultiVariants.find((v) => v.programNumber == stream.key.programNumber && v.sourceName == stream.key.sourceName)) {
+                    const newMv = {
+                        programNumber: stream.key.programNumber,
+                        sourceName: stream.key.sourceName,
+                        node: undefined,
+                    };
+                    this.currentMultiVariants.push(newMv);
+                    (0, logging_1.debuglog)("Creating program-specific multi-variant in AutoPlaylist", { id: this.id, streamKey: stream.key });
+                    if (this.cfg.mode == 'cmaf') {
+                        newMv.node = await this.norsk.output.cmafMultiVariant({
+                            id: `${this.cfg.id}-multivariant-${stream.key.sourceName}-${stream.key.programNumber}-cmaf`,
+                            playlistName: `${this.cfg.name}-${stream.key.sourceName}-${stream.key.programNumber}`,
+                            destinations: this.destinations
+                        });
+                        this.runtime.report.registerOutput(this.cfg.id, newMv.node.url);
+                    }
+                    else {
+                        newMv.node = await this.norsk.output.cmafMultiVariant({
+                            id: `${this.cfg.id}-multivariant-${stream.key.sourceName}-${stream.key.programNumber}-ts`,
+                            playlistName: `${this.cfg.name}-${stream.key.sourceName}-${stream.key.programNumber}`,
+                            destinations: this.destinations
+                        });
+                        this.runtime.report.registerOutput(this.cfg.id, newMv.node.url);
+                    }
+                }
             }
             const streamKeyString = `${stream.key.sourceName}-${stream.key.programNumber}-${stream.key.streamId}-${stream.key.renditionName}`;
+            (0, logging_1.debuglog)("Setting up media nodes for key", { id: this.id, key: stream.key, type: stream.metadata.message.case });
             switch (stream.metadata.message.case) {
                 case undefined:
                     throw "Bad server message";
@@ -166,25 +333,48 @@ class AutoCmaf extends base_nodes_1.CustomSinkNode {
                         m3uAdditions: this.crypto.video.mediaSignaling,
                         mpdAdditions: this.crypto.video.dashSignalling,
                     } : {};
-                    const video = await this.norsk.output.cmafVideo({
-                        segmentDurationSeconds: this.cfg.segments.targetSegmentDuration,
-                        partDurationSeconds: this.cfg.segments.targetPartDuration,
-                        destinations: this.destinations,
-                        id: `${this.id}-${streamKeyString}-video`,
-                        ...videoCryptoSettings,
-                    });
-                    newMedia.node = video;
-                    newMedia.scheduleAd = (ad, destinationId) => {
-                        const now = new Date();
-                        video.scheduleTag(ad, now, destinationId);
+                    let node = undefined;
+                    if (this.cfg.mode == 'cmaf') {
+                        const local = node = await this.norsk.output.cmafVideo({
+                            segmentDurationSeconds: this.cfg.segments.targetSegmentDuration,
+                            partDurationSeconds: this.cfg.segments.targetPartDuration,
+                            destinations: this.destinations,
+                            id: `${this.id}-${streamKeyString}-video-cmaf`,
+                            ...videoCryptoSettings,
+                        });
+                        local.onPlaylistAddition = (_, p) => p;
+                        local.onPlaylistAddition = undefined;
+                        subscribes.push(new Promise((resolve, _reject) => {
+                            local.subscribe([{
+                                    source: stream.source,
+                                    sourceSelector: (0, norsk_sdk_1.selectExactKey)(stream.key)
+                                }], (_) => true, (_) => resolve({}));
+                        }));
+                    }
+                    else {
+                        const local = node = await this.norsk.output.hlsTsVideo({
+                            segmentDurationSeconds: this.cfg.segments.targetSegmentDuration,
+                            destinations: this.destinations,
+                            id: `${this.id}-${streamKeyString}-video-ts`,
+                            ...videoCryptoSettings,
+                        });
+                        subscribes.push(new Promise((resolve, _reject) => {
+                            local.subscribe([{
+                                    source: stream.source,
+                                    sourceSelector: (0, norsk_sdk_1.selectExactKey)(stream.key)
+                                }], (_) => true, (_) => resolve({}));
+                        }));
+                    }
+                    const newMedia = {
+                        key: stream.key,
+                        node,
+                        scheduleAd: (ad, destinationId) => {
+                            const now = new Date();
+                            node?.scheduleTag(ad, now, destinationId);
+                        }
                     };
-                    subscribes.push(new Promise((resolve, _reject) => {
-                        video.subscribe([{
-                                source: stream.source,
-                                sourceSelector: (0, norsk_sdk_1.selectExactKey)(stream.key)
-                            }], (_) => true, (_) => resolve({}));
-                    }));
-                    this.registerInput(video);
+                    this.currentMedia.push(newMedia);
+                    this.registerInput(node);
                     break;
                 }
                 case "audio": {
@@ -193,43 +383,74 @@ class AutoCmaf extends base_nodes_1.CustomSinkNode {
                         m3uAdditions: this.crypto.audio.mediaSignaling,
                         mpdAdditions: this.crypto.audio.dashSignalling,
                     } : {};
-                    const audio = await this.norsk.output.cmafAudio({
-                        segmentDurationSeconds: this.cfg.segments.targetSegmentDuration,
-                        partDurationSeconds: this.cfg.segments.targetPartDuration,
-                        destinations: this.destinations,
-                        id: `${this.id}-${streamKeyString}-audio`,
-                        ...audioCryptoSettings,
-                    });
-                    newMedia.node = audio;
-                    newMedia.scheduleAd = (ad, destinationId) => {
-                        const now = new Date();
-                        audio.scheduleTag(ad, now, destinationId);
+                    let node = undefined;
+                    if (this.cfg.mode == 'cmaf') {
+                        const local = node = await this.norsk.output.cmafAudio({
+                            segmentDurationSeconds: this.cfg.segments.targetSegmentDuration,
+                            partDurationSeconds: this.cfg.segments.targetPartDuration,
+                            destinations: this.destinations,
+                            id: `${this.id}-${streamKeyString}-audio-cmaf`,
+                            ...audioCryptoSettings,
+                        });
+                        local.onPlaylistAddition = (_, p) => p;
+                        local.onPlaylistAddition = undefined;
+                        subscribes.push(new Promise((resolve, _reject) => {
+                            local.subscribe([{
+                                    source: stream.source,
+                                    sourceSelector: (0, norsk_sdk_1.selectExactKey)(stream.key)
+                                }], (_) => true, (_) => resolve({}));
+                        }));
+                    }
+                    else {
+                        const local = node = await this.norsk.output.hlsTsAudio({
+                            segmentDurationSeconds: this.cfg.segments.targetSegmentDuration,
+                            destinations: this.destinations,
+                            id: `${this.id}-${streamKeyString}-audio-ts`,
+                            ...audioCryptoSettings,
+                        });
+                        subscribes.push(new Promise((resolve, _reject) => {
+                            local.subscribe([{
+                                    source: stream.source,
+                                    sourceSelector: (0, norsk_sdk_1.selectExactKey)(stream.key)
+                                }], (_) => true, (_) => resolve({}));
+                        }));
+                    }
+                    const newMedia = {
+                        key: stream.key,
+                        node,
+                        scheduleAd: (ad, destinationId) => {
+                            const now = new Date();
+                            node?.scheduleTag(ad, now, destinationId);
+                        }
                     };
-                    subscribes.push(new Promise((resolve, _reject) => {
-                        audio.subscribe([{
-                                source: stream.source,
-                                sourceSelector: (0, norsk_sdk_1.selectExactKey)(stream.key)
-                            }], (_) => true, (_) => resolve({}));
-                    }));
-                    this.registerInput(audio);
+                    this.currentMedia.push(newMedia);
+                    this.registerInput(node);
                     break;
                 }
                 case "subtitle": {
-                    const subtitle = await this.norsk.output.cmafWebVtt({
-                        segmentDurationSeconds: this.cfg.segments.targetSegmentDuration,
-                        destinations: this.destinations,
-                        id: `${this.id}-${streamKeyString}-webvtt`
-                    });
-                    newMedia.node = subtitle;
-                    newMedia.scheduleAd = (ad, destinationId) => {
-                        const now = new Date();
-                        subtitle.scheduleTag(ad, now, destinationId);
-                    };
-                    subtitle.subscribe([{
-                            source: stream.source,
-                            sourceSelector: (0, norsk_sdk_1.selectExactKey)(stream.key)
-                        }]);
-                    this.registerInput(subtitle);
+                    if (this.cfg.mode == 'cmaf') {
+                        const subtitleCmaf = await this.norsk.output.cmafWebVtt({
+                            segmentDurationSeconds: this.cfg.segments.targetSegmentDuration,
+                            destinations: this.destinations,
+                            id: `${this.id}-${streamKeyString}-webvtt`,
+                        });
+                        subscribes.push(new Promise((resolve, _reject) => {
+                            subtitleCmaf.subscribe([{
+                                    source: stream.source,
+                                    sourceSelector: (0, norsk_sdk_1.selectExactKey)(stream.key)
+                                }], (_) => true, (_) => resolve({}));
+                        }));
+                        const newMedia = {
+                            key: stream.key,
+                            node: subtitleCmaf,
+                            scheduleAd: (ad, destinationId) => {
+                                const now = new Date();
+                                subtitleCmaf.scheduleTag(ad, now, destinationId);
+                            }
+                        };
+                        this.currentMedia.push(newMedia);
+                        this.registerInput(subtitleCmaf);
+                    }
                     break;
                 }
                 case "ancillary": {
@@ -249,16 +470,18 @@ class AutoCmaf extends base_nodes_1.CustomSinkNode {
                                         id: adId,
                                         scte35: message,
                                         startDate: schedule,
-                                        durationSeconds: Number(command.breakDuration.duration / BigInt(90000.0))
+                                        durationSeconds: Number((command.breakDuration?.duration ?? 0n) / BigInt(90000.0))
                                     }, d);
                                 }
                             }
                         }
                     });
-                    ancillary.subscribe([{
-                            source: stream.source,
-                            sourceSelector: (0, norsk_sdk_1.selectExactKey)(stream.key)
-                        }]);
+                    subscribes.push(new Promise((resolve, _reject) => {
+                        ancillary.subscribe([{
+                                source: stream.source,
+                                sourceSelector: (0, norsk_sdk_1.selectExactKey)(stream.key)
+                            }], (_) => true, (_) => resolve({}));
+                    }));
                     this.registerInput(ancillary);
                     break;
                 }
@@ -275,15 +498,15 @@ class AutoCmaf extends base_nodes_1.CustomSinkNode {
             return true;
         });
         for (const deletion of deletions) {
-            const node = deletion?.node;
-            deletion.node = undefined;
-            await node?.close();
+            const node = deletion.node;
             this.currentMedia = this.currentMedia.filter((x) => !(0, norsk_sdk_1.streamKeysAreEqual)(x.key, deletion.key));
+            (0, logging_1.debuglog)("Closing old media node for non-existant key", { id: this.id, key: deletion.key });
+            await node?.close();
         }
-        const thisResponse = this.pendingResponses.shift();
+        (0, logging_1.debuglog)("Waiting for media playlists to be created", { id: this.id, count: creations.length });
         await Promise.all(creations);
         const defaultSources = this.currentMedia.flatMap((m) => {
-            if (m.key.programNumber == this.defaultProgramNumber && m.key.sourceName == this.defaultSourceName && m.node)
+            if (m.key.programNumber == this.defaultProgramNumber && m.key.sourceName == this.defaultSourceName)
                 return [{ source: m.node, sourceSelector: norsk_sdk_1.selectPlaylist }];
             return [];
         });
@@ -292,7 +515,8 @@ class AutoCmaf extends base_nodes_1.CustomSinkNode {
             this.defaultProgramNumber = 0;
             this.defaultSourceName = '';
         }
-        this.mv?.subscribe(defaultSources);
+        this.mv?.subscribe(defaultSources.
+            map((s) => ({ source: s.source, sourceSelector: s.sourceSelector })));
         for (const mv of this.currentMultiVariants) {
             const sources = this.currentMedia.flatMap((m) => {
                 if (m.key.programNumber == mv.programNumber && m.key.sourceName == mv.sourceName && m.node)
@@ -307,10 +531,12 @@ class AutoCmaf extends base_nodes_1.CustomSinkNode {
             mv.node?.subscribe(sources);
         }
         await Promise.all(subscribes);
-        if (thisResponse)
-            thisResponse();
     }
     subscribe(subs) {
+        this.currentSources = new Map();
+        subs.forEach((s) => {
+            this.currentSources.set(s.source, s);
+        });
         this.control.setSources(subs);
     }
 }