eyevinn-channel-engine 3.2.1 → 3.2.2

package/engine/session.js

@@ -289,6 +289,14 @@ class Session {
     this.switchDataForSession.transitionSegments = segments;
     this.switchDataForSession.mediaSeqOffset = mSeqOffset;
 
+    let waitTimeMs = 2000;
+    for (let i = segments[Object.keys(segments)[0]].length - 1; 0 < i; i--) {
+      if (segments[Object.keys(segments)[0]][i].duration) {
+        waitTimeMs = parseInt(1000 * (segments[Object.keys(segments)[0]][i].duration / 3), 10);
+        break;
+      }
+    }
+    
     let isLeader = await this._sessionStateStore.isLeader(this._instanceId);
     if (!isLeader) {
       debug(`[${this._sessionId}]: FOLLOWER: Invalidate cache to ensure having the correct VOD!`);
@@ -315,14 +323,14 @@ class Session {
       }
       debug(`[${this._sessionId}]: NEW LEADER: Setting state=VOD_RELOAD_INIT`);
       this.isSwitchingBackToV2L = true;
-      await this._sessionState.set("state", SessionState.VOD_RELOAD_INIT)
+      await this._sessionState.set("state", SessionState.VOD_RELOAD_INIT);
 
     } else {
       let vodReloaded = await this._sessionState.get("vodReloaded");
-      let attempts = 9;
+      let attempts = 12;
       while (!vodReloaded && attempts > 0) {
-        debug(`[${this._sessionId}]: LEADER: Waiting (1000ms) to buy some time reloading vod and adding it to store! (tries left=${attempts})`);
-        await timer(1000);
+        debug(`[${this._sessionId}]: LEADER: Waiting (${waitTimeMs}ms) to buy some time reloading vod and adding it to store! (tries left=${attempts})`);
+        await timer(waitTimeMs);
         vodReloaded = await this._sessionState.get("vodReloaded");
         attempts--;
       }
@@ -961,6 +969,7 @@ class Session {
         if (!isLeader) {
           debug(`[${this._sessionId}]: not the leader so just waiting for the VOD to be initiated`);
         }
+        this.alreadyClearedVodCache = false;
         return;
       case SessionState.VOD_NEXT_INIT:
         try {

package/engine/stream_switcher.js

@@ -2,8 +2,9 @@ const debug = require("debug")("engine-stream-switcher");
 const crypto = require("crypto");
 const fetch = require("node-fetch");
 const { AbortController } = require("abort-controller");
-const { SessionState } = require('./session_state');
-const { timer } = require("./util")
+const { SessionState } = require("./session_state");
+const { timer, findNearestValue, isValidUrl, fetchWithRetry } = require("./util");
+const m3u8 = require("@eyevinn/m3u8");
 
 const SwitcherState = Object.freeze({
   V2L_TO_LIVE: 1,
@@ -31,8 +32,6 @@ class StreamSwitcher {
     this.working = false;
     this.timeDiff = null;
     this.abortTimeStamp = null;
-
-
     if (config) {
       if (config.sessionId) {
         this.sessionId = config.sessionId;
@@ -47,6 +46,7 @@ class StreamSwitcher {
         this.streamSwitchManager = config.streamSwitchManager;
       }
     }
+    this.prerollsCache = {};
   }
 
   getEventId() {
@@ -59,12 +59,7 @@ class StreamSwitcher {
       debug(`[${this.sessionId}]: Abort Live Stream! Reason: ${message}`);
       try {
         this.abortTimeStamp = Date.now();
-        status = await this._initSwitching(
-          SwitcherState.LIVE_TO_V2L,
-          session,
-          sessionLive,
-          null
-        );
+        status = await this._initSwitching(SwitcherState.LIVE_TO_V2L, session, sessionLive, null);
         return status;
       } catch (err) {
         debug(`Failed to force a switch off live feed: ${err}`);
@@ -89,158 +84,135 @@ class StreamSwitcher {
       debug(`[${this.sessionId}]: streamSwitcher is currently busy`);
       return null;
     }
-    // Handle Complete Storage Reset
-    let sessionState = await session.getSessionState();
-    if (sessionState === SessionState.VOD_INIT || !sessionState) {
-      this.working = true;
-      sessionLive.waitForPlayhead = false;
-      sessionLive.allowedToSet = false; // only have effect on leader
-      await sessionLive.resetSession();
-      await sessionLive.resetLiveStoreAsync(0);
-      this.working = false;
-      this.abortTimeStamp = Date.now() + 20 * 1000; // 30 second V2L->LIVE timeout
-      if (this.streamTypeLive) {
-        debug(`[${this.sessionId}]: [ Ending LIVE Abruptly, Going to -> V2L ]`);
-        this.streamTypeLive = false;
+
+    try {
+      // Handle Complete Storage Reset
+      let sessionState = await session.getSessionState();
+      if (sessionState === SessionState.VOD_INIT || !sessionState) {
+        this.working = true;
+        sessionLive.waitForPlayhead = false;
+        sessionLive.allowedToSet = false; // only have effect on leader
+        await sessionLive.resetSession();
+        await sessionLive.resetLiveStoreAsync(0);
+        this.working = false;
+        this.abortTimeStamp = Date.now() + 30 * 1000; // 30 second V2L->LIVE timeout
+        if (this.streamTypeLive) {
+          debug(`[${this.sessionId}]: [ Ending LIVE Abruptly, Going to -> V2L ]`);
+          this.streamTypeLive = false;
+        }
+        debug(`[${this.sessionId}]: StreamSwitcher reacting to Full Store Reset`);
+        return false; // Go to V2L feed
       }
-      debug(`[${this.sessionId}]: StreamSwitcher reacting to Full Store Reset`);
-      return false; // Go to V2L feed
-    }
 
-    // Filter out schedule objects from the past
-    const tsNow = Date.now();
-    const strmSchedule = await this.streamSwitchManager.getSchedule(this.sessionId);
-    const schedule = strmSchedule.filter((obj) => obj.end_time > tsNow);
-    if (schedule.length === 0 && this.streamTypeLive) {
-      status = await this._initSwitching(
-        SwitcherState.LIVE_TO_V2L,
-        session,
-        sessionLive,
-        null
-      );
-      return status;
-    }
-    if (schedule.length === 0) {
-      this.eventId = null;
-      return false;
-    }
-    const scheduleObj = schedule[0];
-    this.timeDiff = scheduleObj;
-    if (tsNow < scheduleObj.start_time) {
-      if (this.streamTypeLive) {
-        status = await this._initSwitching(
-          SwitcherState.LIVE_TO_V2L,
-          session,
-          sessionLive,
-          null
-        );
+      // Filter out schedule objects from the past
+      const tsNow = Date.now();
+      const strmSchedule = await this.streamSwitchManager.getSchedule(this.sessionId);
+      const schedule = strmSchedule.filter((obj) => obj.end_time > tsNow);
+
+      // Load Preroll, if any, once per channel every (maxAge) seconds
+      if (!this.prerollsCache[this.sessionId] || this.prerollsCache[this.sessionId].maxAge < tsNow) {
+        if (this.streamSwitchManager.getPrerollUri) {
+          const prerollUri = await this.streamSwitchManager.getPrerollUri(this.sessionId);
+          if (isValidUrl(prerollUri)) {
+            try {
+              const segments = await this._loadPreroll(prerollUri);
+              const prerollItem = {
+                segments: segments,
+                maxAge: tsNow + 30 * 60 * 1000,
+              };
+              this.prerollsCache[this.sessionId] = prerollItem;
+            } catch (err) {
+              debug(`[${this.sessionId}]: Failed loading preroll vod for channel=${this.sessionId}`);
+              console.error(err);
+            }
+          } else {
+            debug(`[${this.sessionId}]: Preroll uri:'${prerollUri}' is not a valid URL. Using No preroll.`);
+          }
+        }
+      }
+
+      if (schedule.length === 0 && this.streamTypeLive) {
+        status = await this._initSwitching(SwitcherState.LIVE_TO_V2L, session, sessionLive, null);
         return status;
       }
-      this.eventId = null;
-      return false;
-    }
+      if (schedule.length === 0) {
+        this.eventId = null;
+        return false;
+      }
+      const scheduleObj = schedule[0];
+      this.timeDiff = scheduleObj;
+      if (tsNow < scheduleObj.start_time) {
+        if (this.streamTypeLive) {
+          status = await this._initSwitching(SwitcherState.LIVE_TO_V2L, session, sessionLive, null);
+          return status;
+        }
+        this.eventId = null;
+        return false;
+      }
 
-    let tries = 0;
-    let validURI = false;
-    while (!validURI && tries < MAX_FAILS) {
-      debug(
-        `[${
-          this.sessionId
-        }]: Switcher is validating Master URI... (tries left=${
-          MAX_FAILS - tries
-        })`
-      );
-      validURI = await this._validURI(scheduleObj.uri);
-      tries++;
+      let tries = 0;
+      let validURI = false;
+      while (!validURI && tries < MAX_FAILS) {
+        debug(`[${this.sessionId}]: Switcher is validating Master URI... (tries left=${MAX_FAILS - tries})`);
+        validURI = await this._validURI(scheduleObj.uri);
+        tries++;
+        if (!validURI) {
+          const delayMs = tries * 500;
+          debug(`[${this.sessionId}]: Going to try validating Master URI again in ${delayMs}ms`);
+          await timer(delayMs);
+        }
+      }
       if (!validURI) {
-        const delayMs = tries * 500;
-        debug(`[${this.sessionId}]: Going to try validating Master URI again in ${delayMs}ms`);
-        await timer(delayMs);
+        debug(`[${this.sessionId}]: Unreachable URI: [${scheduleObj.uri}]`);
+        if (this.streamTypeLive) {
+          await this.abortLiveFeed(session, sessionLive, "Switching back to VOD2Live due to unreachable URI");
+        }
+        return false;
       }
-    }
-    if (!validURI) {
-      debug(`[${this.sessionId}]: Unreachable URI: [${scheduleObj.uri}]`);
-      if (this.streamTypeLive) {
-        await this.abortLiveFeed(
-          session,
-          sessionLive,
-          "Switching back to VOD2Live due to unreachable URI"
-        );
+      debug(`[${this.sessionId}]: ....Master URI -> VALID`);
+
+      if (this.abortTimeStamp && tsNow - this.abortTimeStamp <= 10000) {
+        // If we have a valid URI and no more than 10 seconds have passed since switching from Live->V2L.
+        // Stay on V2L to give live sessionLive some time to prepare before switching back to live.
+        debug(`[${this.sessionId}]: Waiting [${10000 - (tsNow - this.abortTimeStamp)}ms] before switching back to Live due to unreachable URI`);
+        return false;
       }
-      return false;
-    }
-    debug(`[${this.sessionId}]: ....Master URI -> VALID`);
-
-    if (this.abortTimeStamp && tsNow - this.abortTimeStamp <= 10000) {
-      // If we have a valid URI and no more than 10 seconds have passed since switching from Live->V2L.
-      // Stay on V2L to give live sessionLive some time to prepare before switching back to live.
-      debug(
-        `[${this.sessionId}]: Waiting [${
-          10000 - (tsNow - this.abortTimeStamp)
-        }ms] before switching back to Live due to unreachable URI`
-      );
-      return false;
-    }
-    this.abortTimeStamp = null;
+      this.abortTimeStamp = null;
 
-    if (this.streamTypeLive) {
-      if (
-        tsNow >= scheduleObj.start_time &&
-        this.eventId !== scheduleObj.eventId
-      ) {
-        if (scheduleObj.type === StreamType.LIVE) {
-          status = await this._initSwitching(
-            SwitcherState.LIVE_TO_LIVE,
-            session,
-            sessionLive,
-            scheduleObj
-          );
+      if (this.streamTypeLive) {
+        if (tsNow >= scheduleObj.start_time && this.eventId !== scheduleObj.eventId) {
+          if (scheduleObj.type === StreamType.LIVE) {
+            status = await this._initSwitching(SwitcherState.LIVE_TO_LIVE, session, sessionLive, scheduleObj);
+            return status;
+          }
+          status = await this._initSwitching(SwitcherState.LIVE_TO_VOD, session, sessionLive, scheduleObj);
           return status;
         }
-        status = await this._initSwitching(
-          SwitcherState.LIVE_TO_VOD,
-          session,
-          sessionLive,
-          scheduleObj
-        );
-        return status;
       }
-    }
-    if (
-      tsNow >= scheduleObj.start_time &&
-      tsNow < scheduleObj.end_time &&
-      scheduleObj.end_time - tsNow > 10000
-    ) {
-      if (scheduleObj.type === StreamType.LIVE) {
-        if (!this.streamTypeLive) {
-          status = await this._initSwitching(
-            SwitcherState.V2L_TO_LIVE,
-            session,
-            sessionLive,
-            scheduleObj
-          );
-          return status;
+      if (tsNow >= scheduleObj.start_time && tsNow < scheduleObj.end_time && scheduleObj.end_time - tsNow > 10000) {
+        if (scheduleObj.type === StreamType.LIVE) {
+          if (!this.streamTypeLive) {
+            status = await this._initSwitching(SwitcherState.V2L_TO_LIVE, session, sessionLive, scheduleObj);
+            return status;
+          }
+          return true;
         }
-        return true;
-      }
-      if (!this.streamTypeLive) {
-        if (!scheduleObj.duration) {
-          debug(
-            `[${this.sessionId}]: Cannot switch VOD no duration specified for schedule item: [${scheduleObj.assetId}]`
-          );
+        if (!this.streamTypeLive) {
+          if (!scheduleObj.duration) {
+            debug(`[${this.sessionId}]: Cannot switch VOD no duration specified for schedule item: [${scheduleObj.assetId}]`);
+            return false;
+          }
+          if (this.eventId !== scheduleObj.eventId) {
+            status = await this._initSwitching(SwitcherState.V2L_TO_VOD, session, sessionLive, scheduleObj);
+            return status;
+          }
           return false;
         }
-        if (this.eventId !== scheduleObj.eventId) {
-          status = await this._initSwitching(
-            SwitcherState.V2L_TO_VOD,
-            session,
-            sessionLive,
-            scheduleObj
-          );
-          return status;
-        }
-        return false;
       }
+    } catch (err) {
+      debug(`[${this.sessionId}]: Unexpected failure in Stream Switcher...`);
+      console.error(err);
+      throw new Error(err);
     }
   }
 
@@ -263,13 +235,15 @@ class StreamSwitcher {
           currVodCounts = await session.getCurrentMediaAndDiscSequenceCount();
           currVodSegments = await session.getCurrentMediaSequenceSegments();
 
+          // Insert preroll if available for current channel
+          if (this.prerollsCache[this.sessionId]) {
+            const prerollSegments = this.prerollsCache[this.sessionId].segments;
+            currVodSegments = this._mergeSegments(prerollSegments, currVodSegments, false);
+          }
           // In risk that the SL-playhead might have updated some data after
           // we reset last time... we should Reset SessionLive before sending new data.
           await sessionLive.resetLiveStoreAsync(0);
-          await sessionLive.setCurrentMediaAndDiscSequenceCount(
-            currVodCounts.mediaSeq,
-            currVodCounts.discSeq
-          );
+          await sessionLive.setCurrentMediaAndDiscSequenceCount(currVodCounts.mediaSeq, currVodCounts.discSeq);
           await sessionLive.setCurrentMediaSequenceSegments(currVodSegments);
           liveUri = await sessionLive.setLiveUri(scheduleObj.uri);
 
@@ -289,6 +263,7 @@ class StreamSwitcher {
           this.working = false;
           this.eventId = null;
           debug(`[${this.sessionId}]: [ ERROR Switching from V2L->LIVE ]`);
+          console.error(err);
           throw new Error(err);
         }
 
@@ -297,10 +272,7 @@ class StreamSwitcher {
           debug(`[${this.sessionId}]: [ INIT Switching from V2L->VOD ]`);
           this.eventId = scheduleObj.eventId;
           currVodCounts = await session.getCurrentMediaAndDiscSequenceCount();
-          eventSegments = await session.getTruncatedVodSegments(
-            scheduleObj.uri,
-            scheduleObj.duration / 1000
-          );
+          eventSegments = await session.getTruncatedVodSegments(scheduleObj.uri, scheduleObj.duration / 1000);
 
           if (!eventSegments) {
             debug(`[${this.sessionId}]: [ ERROR Switching from V2L->VOD ]`);
@@ -309,10 +281,13 @@ class StreamSwitcher {
             return false;
           }
 
-          await session.setCurrentMediaAndDiscSequenceCount(
-            currVodCounts.mediaSeq,
-            currVodCounts.discSeq
-          );
+          // Insert preroll if available for current channel
+          if (this.prerollsCache[this.sessionId]) {
+            const prerollSegments = this.prerollsCache[this.sessionId].segments;
+            eventSegments = this._mergeSegments(prerollSegments, eventSegments, true);
+          }
+
+          await session.setCurrentMediaAndDiscSequenceCount(currVodCounts.mediaSeq, currVodCounts.discSeq);
           await session.setCurrentMediaSequenceSegments(eventSegments, 0, true);
 
           this.working = false;
@@ -336,9 +311,7 @@ class StreamSwitcher {
           sessionLive.resetLiveStoreAsync(RESET_DELAY); // In parallel
 
           if (scheduleObj && !scheduleObj.duration) {
-            debug(
-              `[${this.sessionId}]: Cannot switch VOD. No duration specified for schedule item: [${scheduleObj.assetId}]`
-            );
+            debug(`[${this.sessionId}]: Cannot switch VOD. No duration specified for schedule item: [${scheduleObj.assetId}]`);
           }
 
           if (this._isEmpty(liveSegments.currMseqSegs)) {
@@ -348,14 +321,15 @@ class StreamSwitcher {
             return false;
           }
 
-          await session.setCurrentMediaAndDiscSequenceCount(
-            liveCounts.mediaSeq,
-            liveCounts.discSeq
-          );
-          await session.setCurrentMediaSequenceSegments(
-            liveSegments.currMseqSegs,
-            liveSegments.segCount
-          );
+          // Insert preroll, if available, for current channel
+          if (this.prerollsCache[this.sessionId]) {
+            const prerollSegments = this.prerollsCache[this.sessionId].segments;
+            liveSegments.currMseqSegs = this._mergeSegments(prerollSegments, liveSegments.currMseqSegs, false);
+            liveSegments.segCount += prerollSegments.length;
+          }
+
+          await session.setCurrentMediaAndDiscSequenceCount(liveCounts.mediaSeq, liveCounts.discSeq);
+          await session.setCurrentMediaSequenceSegments(liveSegments.currMseqSegs, liveSegments.segCount);
 
           this.working = false;
           this.streamTypeLive = false;
@@ -378,10 +352,7 @@ class StreamSwitcher {
           await sessionLive.resetSession();
           sessionLive.resetLiveStoreAsync(RESET_DELAY); // In parallel
 
-          eventSegments = await session.getTruncatedVodSegments(
-            scheduleObj.uri,
-            scheduleObj.duration / 1000
-          );
+          eventSegments = await session.getTruncatedVodSegments(scheduleObj.uri, scheduleObj.duration / 1000);
           if (!eventSegments) {
             debug(`[${this.sessionId}]: [ ERROR Switching from LIVE->VOD ]`);
             this.streamTypeLive = false;
@@ -390,14 +361,15 @@ class StreamSwitcher {
             return false;
           }
 
-          await session.setCurrentMediaAndDiscSequenceCount(
-            liveCounts.mediaSeq - 1,
-            liveCounts.discSeq - 1
-          );
-          await session.setCurrentMediaSequenceSegments(
-            liveSegments.currMseqSegs,
-            liveSegments.segCount
-          );
+          await session.setCurrentMediaAndDiscSequenceCount(liveCounts.mediaSeq - 1, liveCounts.discSeq - 1);
+          await session.setCurrentMediaSequenceSegments(liveSegments.currMseqSegs, liveSegments.segCount);
+
+          // Insert preroll, if available, for current channel
+          if (this.prerollsCache[this.sessionId]) {
+            const prerollSegments = this.prerollsCache[this.sessionId].segments;
+            eventSegments = this._mergeSegments(prerollSegments, eventSegments, true);
+          }
+
           await session.setCurrentMediaSequenceSegments(eventSegments, 0, true);
 
           this.working = false;
@@ -417,19 +389,19 @@ class StreamSwitcher {
           // TODO: Not yet fully tested/supported
           this.eventId = scheduleObj.eventId;
           eventSegments = await sessionLive.getCurrentMediaSequenceSegments();
-          currLiveCounts =
-            await sessionLive.getCurrentMediaAndDiscSequenceCount();
+          currLiveCounts = await sessionLive.getCurrentMediaAndDiscSequenceCount();
 
           await sessionLive.resetSession();
           await sessionLive.resetLiveStoreAsync(0);
 
-          await sessionLive.setCurrentMediaAndDiscSequenceCount(
-            currLiveCounts.mediaSeq,
-            currLiveCounts.discSeq
-          );
-          await sessionLive.setCurrentMediaSequenceSegments(
-            eventSegments.currMseqSegs
-          );
+          // Insert preroll, if available, for current channel
+          if (this.prerollsCache[this.sessionId]) {
+            const prerollSegments = this.prerollsCache[this.sessionId].segments;
+            eventSegments = this._mergeSegments(prerollSegments, eventSegments, false);
+          }
+
+          await sessionLive.setCurrentMediaAndDiscSequenceCount(currLiveCounts.mediaSeq, currLiveCounts.discSeq);
+          await sessionLive.setCurrentMediaSequenceSegments(eventSegments.currMseqSegs);
           liveUri = await sessionLive.setLiveUri(scheduleObj.uri);
 
           if (!liveUri) {
@@ -483,19 +455,187 @@ class StreamSwitcher {
       if (online.status >= 200 && online.status < 300) {
         return true;
       }
-      debug(
-        `[${this.sessionId}]: Failed to validate URI: ${uri}\nERROR! Returned Status Code: ${online.status}`
-      );
+      debug(`[${this.sessionId}]: Failed to validate URI: ${uri}\nERROR! Returned Status Code: ${online.status}`);
       return false;
     } catch (err) {
-      debug(
-        `[${this.sessionId}]: Failed to validate URI: ${uri}\nERROR! ${err}`
-      );
+      debug(`[${this.sessionId}]: Failed to validate URI: ${uri}\nERROR: ${err}`);
       return false;
     } finally {
       clearTimeout(timeout);
     }
   }
+
+  async _loadPreroll(uri) {
+    const prerollSegments = {};
+    const mediaM3UPlaylists = {};
+    const mediaURIs = {};
+    try {
+      const m3u = await this._fetchParseM3u8(uri);
+      debug(`[${this.sessionId}]: ...Fetched a New Preroll Slate Master Manifest from:\n${uri}`);
+      // Is the first URI an actual Multivariant manifest
+      if (m3u.items.StreamItem.length > 0) {
+        // Process Master M3U. Collect Media URIs
+        for (let i = 0; i < m3u.items.StreamItem.length; i++) {
+          const streamItem = m3u.items.StreamItem[i];
+          const bw = streamItem.get("bandwidth");
+          const mediaUri = streamItem.get("uri");
+          if (mediaUri.match("^http")) {
+            mediaURIs[bw] = mediaUri;
+          } else {
+            mediaURIs[bw] = new URL(mediaUri, uri);
+          }
+        }
+
+        // Fetch and parse Media URIs
+        const bandwidths = Object.keys(mediaURIs);
+        const loadMediaPromises = [];
+        // Queue up...
+        bandwidths.forEach((bw) => loadMediaPromises.push(this._fetchParseM3u8(mediaURIs[bw])));
+        // Execute...
+        const results = await Promise.allSettled(loadMediaPromises);
+        // Process...
+        results.forEach((item, idx) => {
+          if (item.status === "fulfilled" && item.value) {
+            const resultM3U = item.value;
+            const bw = bandwidths[idx];
+            mediaM3UPlaylists[bw] = resultM3U.items.PlaylistItem;
+          }
+        });
+      } else if (m3u.items.PlaylistItem.length > 0) {
+        // Process the Media M3U.
+        const arbitraryBw = 1;
+        mediaURIs[arbitraryBw] = uri;
+        mediaM3UPlaylists[arbitraryBw] = m3u.items.PlaylistItem;
+      } else {
+        debug(`[${this.sessionId}]: WARNING! M3U has no variants nor playlist segments!`);
+      }
+
+      // Turn original m3u playlist items into custom-simple segment items list
+      const bandwidths = Object.keys(mediaM3UPlaylists);
+      for (let i = 0; i < bandwidths.length; i++) {
+        const bw = bandwidths[i];
+        if (!prerollSegments[bw]) {
+          prerollSegments[bw] = [];
+        }
+        for (let k = 0; k < mediaM3UPlaylists[bw].length; k++) {
+          let seg = {};
+          let playlistItem = mediaM3UPlaylists[bw][k];
+          let segmentUri;
+          let cueData = null;
+          let daterangeData = null;
+          let attributes = playlistItem["attributes"].attributes;
+          if (playlistItem.properties.discontinuity) {
+            prerollSegments[bw].push({ discontinuity: true });
+          }
+          if ("cuein" in attributes) {
+            if (!cueData) {
+              cueData = {};
+            }
+            cueData["in"] = true;
+          }
+          if ("cueout" in attributes) {
+            if (!cueData) {
+              cueData = {};
+            }
+            cueData["out"] = true;
+            cueData["duration"] = attributes["cueout"];
+          }
+          if ("cuecont" in attributes) {
+            if (!cueData) {
+              cueData = {};
+            }
+            cueData["cont"] = true;
+          }
+          if ("scteData" in attributes) {
+            if (!cueData) {
+              cueData = {};
+            }
+            cueData["scteData"] = attributes["scteData"];
+          }
+          if ("assetData" in attributes) {
+            if (!cueData) {
+              cueData = {};
+            }
+            cueData["assetData"] = attributes["assetData"];
+          }
+          if ("daterange" in attributes) {
+            if (!daterangeData) {
+              daterangeData = {};
+            }
+            let allDaterangeAttributes = Object.keys(attributes["daterange"]);
+            allDaterangeAttributes.forEach((attr) => {
+              if (attr.match(/DURATION$/)) {
+                daterangeData[attr.toLowerCase()] = parseFloat(attributes["daterange"][attr]);
+              } else {
+                daterangeData[attr.toLowerCase()] = attributes["daterange"][attr];
+              }
+            });
+          }
+          if (playlistItem.properties.uri) {
+            if (playlistItem.properties.uri.match("^http")) {
+              segmentUri = playlistItem.properties.uri;
+            } else {
+              segmentUri = new URL(playlistItem.properties.uri, mediaURIs[bw]);
+            }
+            seg["duration"] = playlistItem.properties.duration;
+            seg["uri"] = segmentUri;
+            seg["cue"] = cueData;
+            if (daterangeData) {
+              seg["daterange"] = daterangeData;
+            }
+          }
+          prerollSegments[bw].push(seg);
+        }
+      }
+      debug(`[${this.sessionId}]: Loaded all Variants of the Preroll Slate!`);
+      return prerollSegments;
+    } catch (err) {
+      throw new Error(err);
+    }
+  }
+
+  // Input: hls vod uri. Output: an M3U object.
+  async _fetchParseM3u8(uri) {
+    const parser = m3u8.createStream();
+    try {
+      const res = await fetchWithRetry(uri, {}, 5, 1000, 1500, debug);
+      res.body.pipe(parser);
+      return new Promise((resolve, reject) => {
+        parser.on("m3u", (m3u) => {
+          resolve(m3u);
+          parser.on("error", (exc) => {
+            debug(`Parser Error: ${JSON.stringify(exc)}`);
+            reject(exc);
+          });
+        });
+      });
+    } catch (err) {
+      return Promise.reject(`[${this.sessionId}]: Failed to Fetch URI: ${uri}\nERROR, ${err}`);
+    }
+  }
+
+  _mergeSegments(fromSegments, toSegments, prepend) {
+    const OUTPUT_SEGMENTS = {};
+    const fromBws = Object.keys(fromSegments);
+    const toBws = Object.keys(toSegments);
+    toBws.forEach((bw) => {
+      const targetBw = findNearestValue(bw, fromBws);
+      if (prepend) {
+        OUTPUT_SEGMENTS[bw] = fromSegments[targetBw].concat(toSegments[bw]);
+        OUTPUT_SEGMENTS[bw].unshift({ discontinuity: true });
+      } else {
+        const lastSeg = toSegments[bw][toSegments[bw].length - 1];
+        if (lastSeg.uri && !lastSeg.discontinuity) {
+          toSegments[bw].push({ discontinuity: true });
+          OUTPUT_SEGMENTS[bw] = toSegments[bw].concat(fromSegments[targetBw]);
+        } else {
+          OUTPUT_SEGMENTS[bw] = toSegments[bw].concat(fromSegments[targetBw]);
+          OUTPUT_SEGMENTS[bw].push({ discontinuity: true });
+        }
+      }
+    });
+    return OUTPUT_SEGMENTS;
+  }
 }
 
 module.exports = StreamSwitcher;

package/engine/util.js

@@ -1,4 +1,5 @@
 const { version } = require("../package.json");
+const fetch = require("node-fetch");
 
 const filterQueryParser = (filterQuery) => {
   const conditions = filterQuery.match(/\(([^\(\)]*?)\)/g);
@@ -150,6 +151,68 @@ class WaitTimeGenerator {
   }
 }
 
+const findNearestValue = (val, array) => {
+  const sorted = array.sort((a, b) => b - a);
+  return sorted.reduce((a, b) => {
+    return Math.abs(b - val) < Math.abs(a - val) ? b : a;
+  });
+}
+
+const isValidUrl = (url) => {
+  try {
+    const _url = new URL(url);
+    return true;
+  } catch (err) {
+    return false;
+  }
+}
+
+
+const fetchWithRetry = async (uri, opts, maxRetries, retryDelayMs, timeoutMs, debug) => {
+  if (!debug) {
+    var debug = (msg) => { console.log(msg); };
+  } 
+  let tryFetchCount = 0;
+  const RETRY_LIMIT = maxRetries || 5;
+  const TIMEOUT_LIMIT = timeoutMs || 10 * 1000;
+  const RETRY_DELAY = retryDelayMs || 1000;
+  while (tryFetchCount < RETRY_LIMIT) {
+    tryFetchCount++;
+    debug(`Fetching URI -> ${uri}, attempt ${tryFetchCount} of ${maxRetries}`);
+    //
+    const controller = new AbortController();
+    const timeout = setTimeout(() => {
+      `Request Timeout after (${TIMEOUT_LIMIT})ms @ ${uri}`;
+      controller.abort();
+    }, TIMEOUT_LIMIT);
+    try {
+      const fetchOpts = Object.assign({ signal: controller.signal }, opts);
+      const response = await fetch(uri, fetchOpts);
+
+      if (response.status >= 400 && response.status < 600) {
+        const msg = `Bad response from URI: ${uri}\nReturned Status Code: ${response.status}`;
+        debug(msg);
+        if (tryFetchCount === maxRetries) {
+          return Promise.resolve(response);
+        }
+        debug(`Going to try fetch again in ${RETRY_DELAY}ms`);
+        await timer(RETRY_DELAY);
+        continue;
+      }
+      // Return Good response
+      return Promise.resolve(response);
+    } catch (err) {
+      debug(`Node-Fetch Error on URI: ${uri}\nFull Error -> ${err}`);
+      if (tryFetchCount === maxRetries) {
+        return Promise.reject(err);
+      }
+      continue;
+    } finally {
+      clearTimeout(timeout);
+    }
+  }
+};
+
 module.exports = {
   filterQueryParser,
   applyFilter,
@@ -159,4 +222,7 @@ module.exports = {
   logerror,
   timer,
   WaitTimeGenerator,
+  findNearestValue,
+  isValidUrl,
+  fetchWithRetry
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eyevinn-channel-engine",
-  "version": "3.2.1",
+  "version": "3.2.2",
   "description": "OTT TV Channel Engine",
   "main": "index.js",
   "scripts": {

package/server-livemix.js

@@ -136,6 +136,11 @@ class StreamSwitchManager {
     return uuidv4();
   }
 
+  getPrerollUri(channelId) {
+    const defaultPrerollSlateUri = "https://maitv-vod.lab.eyevinn.technology/slate-consuo.mp4/master.m3u8"
+    return new Promise((resolve, reject) => { resolve(defaultPrerollSlateUri); });
+  }
+
   getSchedule(channelId) {
     return new Promise((resolve, reject) => {
       if (this.schedule[channelId]) {
@@ -155,7 +160,7 @@ class StreamSwitchManager {
             type: StreamType.LIVE,
             start_time: startOffset,
             end_time: endTime,
-            uri: "https://d2fz24s2fts31b.cloudfront.net/out/v1/2e5b17b7dd0548c7b844eb1b311b6434/manifest.m3u8",
+            uri: "https://d2fz24s2fts31b.cloudfront.net/out/v1/6484d7c664924b77893f9b4f63080e5d/manifest.m3u8",
           },
           {
             eventId: this.generateID(),