eyevinn-channel-engine 3.1.8 → 3.2.1

package/engine/server.js

@@ -12,7 +12,7 @@ const { SessionStateStore } = require('./session_state.js');
 const { SessionLiveStateStore } = require('./session_live_state.js');
 const { PlayheadStateStore } = require('./playhead_state.js');
 
-const { filterQueryParser, toHHMMSS } = require('./util.js');
+const { filterQueryParser, toHHMMSS, WaitTimeGenerator } = require('./util.js');
 const { version } = require('../package.json');
 
 const timer = ms => new Promise(res => setTimeout(res, ms));
@@ -166,14 +166,17 @@ class ChannelEngine {
     }, 3000);
 
     const StreamSwitchLoop = async (timeIntervalMs) => {
+      const minIntervalMs = 50;
+      const WTG = new WaitTimeGenerator(timeIntervalMs, minIntervalMs);
       while(true) {
         try {
           const ts_1 = Date.now();
           await this.updateStreamSwitchAsync()
           const ts_2 = Date.now();
-          let interval = (timeIntervalMs - (ts_2 - ts_1)) < 0 ? 50 : (timeIntervalMs - (ts_2 - ts_1)); 
-          await timer(interval)
-          debug(`StreamSwitchLoop waited for all channels. Next tick in: ${interval}ms`)
+          const  interval = (timeIntervalMs - (ts_2 - ts_1)) < 0 ? minIntervalMs : (timeIntervalMs - (ts_2 - ts_1)); 
+          const tickInterval = await WTG.getWaitTime(interval);
+          await timer(tickInterval)
+          debug(`StreamSwitchLoop waited for all channels. Next tick in: ${tickInterval}ms`)
         } catch (err) {
           console.error(err)
           debug(`StreamSwitchLoop iteration failed. Trying Again in 1000ms!`);

package/engine/session.js

@@ -57,6 +57,7 @@ class Session {
       transitionSegments: null,
       reloadBehind: null,
     }
+    this.alreadyClearedVodCache = null;
 
     if (config) {
       if (config.sessionId) {
@@ -353,12 +354,9 @@ class Session {
     }
 
     const playheadState = await this._playheadState.getValues(["mediaSeq", "vodMediaSeqVideo"]);
-    if (playheadState.vodMediaSeqVideo === 0) {
-      if (!isLeader) {
-        debug(`[${this._sessionId}]: Not a leader and first media sequence in a VOD is requested. Invalidate cache to ensure having the correct VOD.`);
-        await this._sessionState.clearCurrentVodCache(); // force reading up from shared store
-      }
-    }
+
+    // NOTE: Assume that VOD cache was already cleared in 'getCurrentMediaAndDiscSequenceCount()'
+    // and that we now have access to the correct vod cache
     const currentVod = await this._sessionState.getCurrentVod();
     if (currentVod) {
       try {
@@ -404,10 +402,11 @@ class Session {
     
     const playheadState = await this._playheadState.getValues(["mediaSeq", "vodMediaSeqVideo"]);
     const discSeqOffset = await this._sessionState.get("discSeq");
+    // Clear Vod Cache here when Switching to Live just to be safe...
     if (playheadState.vodMediaSeqVideo === 0) {
       const isLeader = await this._sessionStateStore.isLeader(this._instanceId);
       if (!isLeader) {
-        debug(`[${this._sessionId}]: Not a leader and first media sequence in a VOD is requested. Invalidate cache to ensure having the correct VOD.`);
+        debug(`[${this._sessionId}]: Not a leader, about to switch, and first media sequence in a VOD is requested. Invalidate cache to ensure having the correct VOD.`);
         await this._sessionState.clearCurrentVodCache(); // force reading up from shared store
       }
     }
@@ -446,7 +445,7 @@ class Session {
     const sessionState = await this._sessionState.getValues(["vodMediaSeqVideo", "discSeq"]);
     const playheadState = await this._playheadState.getValues(["mediaSeq", "vodMediaSeqVideo"]);
 
-    if (this.prevVodMediaSeq.video !== null) {
+    if (this.prevVodMediaSeq.video === null) {
       this.prevVodMediaSeq.video = playheadState.vodMediaSeqVideo;
     }
 
@@ -461,13 +460,18 @@ class Session {
       }
     }
 
+    // Force reading up from store, but only once if the condition is right
     if (playheadState.vodMediaSeqVideo < 2 || playheadState.vodMediaSeqVideo < this.prevVodMediaSeq.video) { 
       debug(`[${this._sessionId}]: current[${playheadState.vodMediaSeqVideo}]_prev[${this.prevVodMediaSeq.video}]`);
       const isLeader = await this._sessionStateStore.isLeader(this._instanceId);
-      if (!isLeader) {
+      if (!isLeader && !this.alreadyClearedVodCache) {
         debug(`[${this._sessionId}]: Not a leader and first|second media sequence in a VOD is requested. Invalidate cache to ensure having the correct VOD.`);
-        await this._sessionState.clearCurrentVodCache(); // force reading up from shared store
+        await this._sessionState.clearCurrentVodCache();
+        this.alreadyClearedVodCache = true;
       }
+    } else {
+      // Reset the value
+      this.alreadyClearedVodCache = false;
     }
 
     const currentVod = await this._sessionState.getCurrentVod();
@@ -575,10 +579,23 @@ class Session {
     let m3u8 = currentVod.getLiveMediaSequences(playheadState.mediaSeq, 180000, playheadState.vodMediaSeqVideo, sessionState.discSeq);
     await this._playheadState.setLastM3u8(m3u8);
 
-    if (!isLeader && playheadState.vodMediaSeqVideo < 2) {
-      debug(`[${this._sessionId}]: Not a leader and have just set playheadState vodMediaSeqVideo to 0|1. Invalidate cache to ensure having the correct VOD.`);
-      await this._sessionState.clearCurrentVodCache();
+    // As a FOLLOWER, we might need to read up from shared store... 
+    if (playheadState.vodMediaSeqVideo < 2 || playheadState.vodMediaSeqVideo < this.prevVodMediaSeq.video) { 
+      debug(`[${this._sessionId}]: current[${playheadState.vodMediaSeqVideo}]_prev[${this.prevVodMediaSeq.video}]`);
+      if (playheadState.vodMediaSeqVideo < this.prevVodMediaSeq.video) {
+        this.alreadyCleredVodCache = false;
+      }
+      if (!isLeader && !this.alreadyClearedVodCache) {
+        debug(`[${this._sessionId}]: Not a leader and have just set 'playheadState.vodMediaSeqVideo' to 0|1. Invalidate cache to ensure having the correct VOD.`);
+        await this._sessionState.clearCurrentVodCache();
+        this.alreadyClearedVodCache = true;
+      }
+    } else {
+      // Reset the value
+      this.alreadyClearedVodCache = false;
     }
+    // Update Value for Previous Sequence
+    this.prevVodMediaSeq.video = playheadState.vodMediaSeqVideo;
 
     return m3u8;
   }
@@ -834,13 +851,6 @@ class Session {
       sessionState.state = SessionState.VOD_INIT;
     }
 
-    if (!isLeader && this.waitingForNextVod) {
-      // By now Leader should have added the next Vod in store
-      debug(`[${this._sessionId}]: Not leader! New VOD loaded during last tick. Invalidate current VOD cache`);
-      await this._sessionState.clearCurrentVodCache();
-      this.waitingForNextVod = false;
-    }
-
     switch (sessionState.state) {
       case SessionState.VOD_INIT:
       case SessionState.VOD_INIT_BY_ID:
@@ -931,19 +941,13 @@ class Session {
           }
         }
       case SessionState.VOD_PLAYING:
-        if (!isLeader) {
-          if (sessionState.vodMediaSeqVideo === 0 || this.waitingForNextVod) {
-            debug(`[${this._sessionId}]: Not leader! Invalidate current VOD cache and fetch the new one from the leader`);
-            await this._sessionState.clearCurrentVodCache();
-            currentVod = await this._sessionState.getCurrentVod();
-            this.waitingForNextVod = false;
-          }
-        } else {
+        if (isLeader) {
           // Handle edge case where store has been reset, but leader has not cleared cache.
-          if (this.prevVodMediaSeq.video !== null) {
+          if (this.prevVodMediaSeq.video === null) {
             this.prevVodMediaSeq.video = sessionState.vodMediaSeqVideo;
           }
-          if (this.prevVodMediaSeq.video < sessionState.vodMediaSeqVideo) {
+          // Clear Cache if prev count is HIGHER than current...
+          if (sessionState.vodMediaSeqVideo < this.prevVodMediaSeq.video ) {
             debug(`[${this._sessionId}]: current[${sessionState.vodMediaSeqVideo}], prev[${this.prevVodMediaSeq.video}], total[${currentVod.getLiveMediaSequencesCount()}]`);
             await this._sessionState.clearCurrentVodCache();
             currentVod = await this._sessionState.getCurrentVod();
@@ -956,11 +960,6 @@ class Session {
         debug(`[${this._sessionId}]: state=VOD_NEXT_INITIATING (${sessionState.vodMediaSeqVideo}_${sessionState.vodMediaSeqAudio}, ${currentVod.getLiveMediaSequencesCount()})`);
         if (!isLeader) {
           debug(`[${this._sessionId}]: not the leader so just waiting for the VOD to be initiated`);
-          if (sessionState.vodMediaSeqVideo === 0 || this.waitingForNextVod) {
-            debug(`[${this._sessionId}]: First mediasequence in VOD and I am not the leader so invalidate current VOD cache and fetch the new one from the leader`);
-            await this._sessionState.clearCurrentVodCache();
-          }
-          this.waitingForNextVod = true;
         }
         return;
       case SessionState.VOD_NEXT_INIT:

package/engine/session_live.js

@@ -159,16 +159,16 @@ class SessionLive {
         this.waitForPlayhead = false;
 
         // Let the playhead move at an interval set according to live segment duration
-        let liveSegmentDurationMs = DEFAULT_PLAYHEAD_INTERVAL_MS;
-        let liveBws = Object.keys(this.liveSegQueue);
-        if (liveBws.length !== 0 && this.liveSegQueue[liveBws[0]].length !== 0 && this.liveSegQueue[liveBws[0]][0].duration) {
-          liveSegmentDurationMs = this.liveSegQueue[liveBws[0]][0].duration * 1000;
-        }
+        const liveSegmentDurationMs = this._getAnyFirstSegmentDurationMs() || DEFAULT_PLAYHEAD_INTERVAL_MS;
 
         // Set the timer
         let timerValueMs = 0;
         if (this.timerCompensation) {
-          if (liveSegmentDurationMs - (tsIncrementEnd - tsIncrementBegin) > 0) {
+          const isLeader = await this.sessionLiveStateStore.isLeader(this.instanceId);
+          const incrementDuration = tsIncrementEnd - tsIncrementBegin;
+          if (incrementDuration >= liveSegmentDurationMs * 0.5 && isLeader) {
+            timerValueMs = liveSegmentDurationMs;
+          } else {
             timerValueMs = liveSegmentDurationMs - (tsIncrementEnd - tsIncrementBegin);
           }
         } else {
@@ -541,12 +541,14 @@ class SessionLive {
       if (!leadersMediaSeqRaw < this.lastRequestedMediaSeqRaw && this.blockGenerateManifest) {
         this.blockGenerateManifest = false;
       }
-      let attempts = 5;
 
+      let attempts = 5;
       //  CHECK AGAIN CASE 1: Store Empty
       while (!leadersMediaSeqRaw && attempts > 0) {
-        debug(`[${this.sessionId}]: FOLLOWER: Leader has not put anything in store... Will check again in 2000ms (Tries left=[${attempts}])`);
-        await timer(2000);
+        const segDur = this._getAnyFirstSegmentDurationMs() || DEFAULT_PLAYHEAD_INTERVAL_MS;
+        const waitTimeMs = parseInt(segDur / 3, 10);
+        debug(`[${this.sessionId}]: FOLLOWER: Leader has not put anything in store... Will check again in ${waitTimeMs}ms (Tries left=[${attempts}])`);
+        await timer(waitTimeMs);
         this.timerCompensation = false;
         leadersMediaSeqRaw = await this.sessionLiveState.get("lastRequestedMediaSeqRaw");
         attempts--;
@@ -566,8 +568,10 @@ class SessionLive {
       attempts = 5;
       //  CHECK AGAIN CASE 2: Store Old
       while (leadersMediaSeqRaw <= this.lastRequestedMediaSeqRaw && attempts > 0) {
-        debug(`[${this.sessionId}]: FOLLOWER: Cannot find anything NEW in store... Will check again in 2000ms (Tries left=[${attempts}])`);
-        await timer(2000);
+        const segDur = this._getAnyFirstSegmentDurationMs() || DEFAULT_PLAYHEAD_INTERVAL_MS;
+        const waitTimeMs = parseInt(segDur / 3, 10);
+        debug(`[${this.sessionId}]: FOLLOWER: Cannot find anything NEW in store... Will check again in ${waitTimeMs}ms (Tries left=[${attempts}])`);
+        await timer(waitTimeMs);
         this.timerCompensation = false;
         leadersMediaSeqRaw = await this.sessionLiveState.get("lastRequestedMediaSeqRaw");
         attempts--;
@@ -632,7 +636,9 @@ class SessionLive {
 
       // Handle if any promise got rejected
       if (manifestList.some((result) => result.status === "rejected")) {
-        debug(`[${this.sessionId}]: ALERT! Promises I: Failed, Rejection Found! Trying again...`);
+        FETCH_ATTEMPTS--;
+        debug(`[${this.sessionId}]: ALERT! Promises I: Failed, Rejection Found! Trying again in 1000ms...`);
+        await timer(1000)
         continue;
       }
 
@@ -1362,6 +1368,27 @@ class SessionLive {
     this.mediaManifestURIs = newItem;
   }
 
+  _getAnyFirstSegmentDurationMs() {
+    if (this._isEmpty(this.liveSegQueue)) {
+      return null;
+    }
+  
+    const bw0 = Object.keys(this.liveSegQueue)[0]; 
+    if (this.liveSegQueue[bw0].length === 0) {
+      return null;
+    }
+    
+    for (let i = 0; i < this.liveSegQueue[bw0].length; i++) {
+      const segment = this.liveSegQueue[bw0][i];
+      if (!segment.duration) {
+        continue;
+      }
+      return segment.duration * 1000;
+    }
+
+    return null;
+  }
+
   _isEmpty(obj) {
     if (!obj) {
       return true;

package/engine/stream_switcher.js

@@ -3,6 +3,7 @@ const crypto = require("crypto");
 const fetch = require("node-fetch");
 const { AbortController } = require("abort-controller");
 const { SessionState } = require('./session_state');
+const { timer } = require("./util")
 
 const SwitcherState = Object.freeze({
   V2L_TO_LIVE: 1,
@@ -151,6 +152,11 @@ class StreamSwitcher {
       );
       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) {
       debug(`[${this.sessionId}]: Unreachable URI: [${scheduleObj.uri}]`);

package/engine/util.js

@@ -122,6 +122,34 @@ const logerror = (sessionId, err) => {
   console.error(err);
 };
 
+const timer = (ms) => new Promise((res) => setTimeout(res, ms));
+
+class WaitTimeGenerator {
+  constructor(defaultIntervalMs, minValue) {
+    (this.timestamp = null), (this.prevWaitTime = null), (this.defaultIntervalMs = defaultIntervalMs || 3000), (this.minValue = minValue);
+  }
+  _getWaitTimeFromTimestamp() {
+    if (!this.timestamp) {
+      this.timestamp = new Date();
+    }
+    const sec = this.timestamp.getSeconds();
+    const defaultSec = this.defaultIntervalMs / 1000;
+    const d = parseInt(sec / defaultSec);
+    const waitSec = defaultSec * (d + 1) - sec;
+    return waitSec * 1000;
+  }
+  async getWaitTime(plannedTime) {
+    if (!this.timestamp || (this.prevWaitTime === this.minValue && plannedTime !== this.minValue)) {
+      this.timestamp = new Date();
+      const waitMs = this._getWaitTimeFromTimestamp();
+      this.prevWaitTime = waitMs;
+      return waitMs;
+    }
+    this.prevWaitTime = plannedTime;
+    return plannedTime;
+  }
+}
+
 module.exports = {
   filterQueryParser,
   applyFilter,
@@ -129,4 +157,6 @@ module.exports = {
   m3u8Header,
   toHHMMSS,
   logerror,
+  timer,
+  WaitTimeGenerator,
 };

package/package.json

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