eyevinn-channel-engine 3.0.1 → 3.0.5

package/.github/workflows/nodejs.yml

@@ -9,7 +9,7 @@ jobs:
 
     strategy:
       matrix:
-        node-version: [10.x, 12.x, 14.x]
+        node-version: [12.x, 14.x]
 
     steps:
     - uses: actions/checkout@v1

package/README.md

@@ -141,8 +141,9 @@ class MyStreamSwitchManager {
   getSchedule(channelId) -> [ { eventId, assetId, title, type, start_time, end_time, uri, duration } ]
 }
 ```
+When using **Live Mixing** in **High-Availablilty** mode, it is important to know that the class's  `getSchedule(channelId)` function will be called by each channel-engine instance. Meaning that it is crucial that the implementation of this function will return the same response for each and every channel-engine instance, as they are expecting to be recieving identical lists in order to be synced up for live mixing. 
 
-The class's `getSchedule(channelId)` function should return a list of event objects in the following format:
+The class's `getSchedule(channelId)` function should return a promise containing the list of events as an object in the following format below:
 
 ```
 {
@@ -208,6 +209,7 @@ Below are examples of a Live stream event and a VOD event respectively:
 (*Important Note: When it comes to VOD events. Desired `duration` has priority over `end_time`. Meaning that you will only resume VOD2Live content after the asset in the VOD event has finished. This may change in the future.*) 
 
 
+
 Then create an instance of the class and reference it as the `streamSwitchManager` in your engineOptions, just like you'd do with the channel manager. 
 
 ```

package/engine/server.js

@@ -167,12 +167,18 @@ class ChannelEngine {
 
     const StreamSwitchLoop = async (timeIntervalMs) => {
       while(true) {
-        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(`SteamSwitchLoop waited for all channels. Next tick in: ${interval}ms`)
+        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`)
+        } catch (err) {
+          console.error(err)
+          debug(`StreamSwitchLoop iteration failed. Trying Again in 1000ms!`);
+          await timer(1000);
+        }
       }
     }
     StreamSwitchLoop(this.streamSwitchTimeIntervalMs);
@@ -188,6 +194,7 @@ class ChannelEngine {
         let status = null;
         try {
           status = await switcher.streamSwitcher(sessions[channel], sessionsLive[channel]);
+          debug(`[${channel}]: streamSwitcher returned switchstatus=${status}`);
           if (status === undefined) {
             debug(`[WARNING]: switcherStatus->${status}. Setting value to previous status->${prevStatus}`);
             status = prevStatus;
@@ -200,7 +207,13 @@ class ChannelEngine {
         debug(`Tried to switch stream on a non-existing channel=[${channel}]. Switching Ignored!)`);
       }
     }
-    await Promise.all(channels.map(channel => getSwitchStatusAndPerformSwitch(channel)));
+    try {
+      await Promise.all(channels.map(channel => getSwitchStatusAndPerformSwitch(channel)));
+    } catch (err) {
+      debug('Problem occured when updating streamSwitchers');
+      throw new Error (err);
+    }
+
   }
 
   async updateChannelsAsync(channelMgr, options) {
@@ -521,7 +534,7 @@ class ChannelEngine {
           await timer(500);
         }
         let body = null;
-        debug(`switcherStatus[req.params[1]]=[${switcherStatus[req.params[1]]}]`);
+        debug(`switcherStatus[${req.params[1]}]=[${switcherStatus[req.params[1]]}]`);
         if (switcherStatus[req.params[1]]) {
           debug(`[${req.params[1]}]: Responding with Live-stream manifest`);
           body = await sessionLive.getCurrentMediaManifestAsync(req.params[0]);
@@ -663,8 +676,9 @@ class ChannelEngine {
     let sessionResets = [];
     for (const sessionId of Object.keys(sessions)) {
       const session = sessions[sessionId];
-      if (session) {
-        await session.resetAsync();
+      const sessionLive = sessionsLive[sessionId];
+      if (session && sessionLive) {
+        await session.resetAsync(); 
         sessionResets.push(sessionId);
       } else {
         const err = new errs.NotFoundError('Invalid session');

package/engine/session.js

@@ -43,6 +43,7 @@ class Session {
     this.playheadDiffThreshold = DEFAULT_PLAYHEAD_DIFF_THRESHOLD;
     this.maxTickInterval = DEFAULT_MAX_TICK_INTERVAL;
     this.diffCompensation = null;
+    this.waitingForNextVod = false;
 
     if (config) {
       if (config.sessionId) {
@@ -362,6 +363,7 @@ class Session {
       throw new Error('Session not ready');
     }
     const playheadState = await this._playheadState.getValues(["mediaSeq", "vodMediaSeqVideo"]);
+    const discSeqOffset = await this._sessionState.get("discSeq");
     if (playheadState.vodMediaSeqVideo === 0) {
       const isLeader = await this._sessionStateStore.isLeader(this._instanceId);
       if (!isLeader) {
@@ -372,7 +374,7 @@ class Session {
     const currentVod = await this._sessionState.getCurrentVod();
     if (currentVod) {
       try {
-        const discSeqCount = currentVod.getLastUsedDiscSeq();
+        const discSeqCount = discSeqOffset + currentVod.discontinuities[playheadState.vodMediaSeqVideo];
         debug(`[${this._sessionId}]: MediaSeq: (${(playheadState.mediaSeq + playheadState.vodMediaSeqVideo)}) and DiscSeq: (${discSeqCount}) requested `);
         return {
           'mediaSeq': (playheadState.mediaSeq + playheadState.vodMediaSeqVideo),
@@ -756,6 +758,13 @@ 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:
@@ -842,10 +851,13 @@ class Session {
           }
         }
       case SessionState.VOD_PLAYING:
-        if (!isLeader && sessionState.vodMediaSeqVideo === 0) {
-          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();
-          currentVod = await this._sessionState.getCurrentVod();
+        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;
+          }
         }
         debug(`[${this._sessionId}]: state=VOD_PLAYING (${sessionState.vodMediaSeqVideo}_${sessionState.vodMediaSeqAudio}, ${currentVod.getLiveMediaSequencesCount()})`);
         return;
@@ -853,10 +865,11 @@ 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) {
+          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:
@@ -938,6 +951,7 @@ class Session {
             return;
           } else {
             debug(`[${this._sessionId}]: not a leader so will go directly to state VOD_NEXT_INITIATING`);
+            this.waitingForNextVod = true;
             sessionState.state = await this._sessionState.set("state", SessionState.VOD_NEXT_INITIATING);
             sessionState.currentVod = await this._sessionState.getCurrentVod();
           }

package/engine/session_live.js

@@ -136,7 +136,7 @@ class SessionLive {
         if (!this.masterManifestUri) {
           await timer(3000);
           continue;
-        }
+        } 
         if (this.playheadState === PlayheadState.STOPPED) {
           debug(`[${this.sessionId}]: Playhead has Stopped, clearing local session and store.`);
           this.waitForPlayhead = false;
@@ -289,6 +289,13 @@ class SessionLive {
     // Don't use what Session gave you. Use the Leaders number if it's available
     const isLeader = await this.sessionLiveStateStore.isLeader(this.instanceId);
     let liveCounts = await this.sessionLiveState.get("firstCounts");
+    if (liveCounts === null) {
+      liveCounts = {
+        liveSourceMseqCount: null,
+        mediaSeqCount: null,
+        discSeqCount: null,
+      };
+    }
     if (isLeader) {
       liveCounts.discSeqCount = this.discSeqCount;
       await this.sessionLiveState.set("firstCounts", liveCounts);
@@ -479,9 +486,13 @@ class SessionLive {
     const vodBws = Object.keys(this.vodSegments);
     const liveBws = Object.keys(this.liveSegsForFollowers);
     const size = this.liveSegsForFollowers[liveBws[0]].length;
-    debug(`[${this.sessionId}]: [size=${size}]->this.liveSegsForFollowers=${Object.keys(this.liveSegsForFollowers)} `);
+
+    let newSegCount = 0;
+    this.liveSegsForFollowers[liveBws[0]].map((seg) => {if (seg.uri) { newSegCount++ }});
+
+    debug(`[${this.sessionId}]: FOLLOWER: liveSegsForFollowers Bws=${Object.keys(this.liveSegsForFollowers)}_newSegCount=${newSegCount} `);
     // Remove transitional segs & add live source segs collected from store
-    for (let k = 0; k < size; k++) {
+    for (let k = 0; k < newSegCount; k++) {
       let incrementDiscSeqCount = false;
       // Shift the top vod segment on all variants
       for (let i = 0; i < vodBws.length; i++) {
@@ -493,12 +504,13 @@ class SessionLive {
       }
       if (incrementDiscSeqCount) {
         this.discSeqCount++;
-        incrementDiscSeqCount = false;
       }
-      // Push to bottom, new live source segment on all variants
-      for (let i = 0; i < liveBws.length; i++) {
-        const bw = liveBws[i];
-        const liveSegFromLeader = this.liveSegsForFollowers[bw][k];
+    }
+    // Push to bottom, new live source segment on all variants
+    for (let segIdx = 0; segIdx < size; segIdx++) {
+      let incrementDiscSeqCount = false;
+      liveBws.forEach((bw)=>{
+        let liveSegFromLeader = this.liveSegsForFollowers[bw][segIdx];
         if (!this.liveSegQueue[bw]) {
           this.liveSegQueue[bw] = [];
         }
@@ -507,19 +519,21 @@ class SessionLive {
         let segCount = 0;
         this.liveSegQueue[bw].map((seg) => {if (seg.uri) { segCount++ }});
         if (segCount > this.targetNumSeg) {
-          seg = this.liveSegQueue[bw].shift();
+          let seg = this.liveSegQueue[bw].shift();
           if (seg && seg.discontinuity) {
             incrementDiscSeqCount = true;
             seg = this.liveSegQueue[bw].shift();
           }
         }
-        debug(`[${this.sessionId}]: Pushed a segment to 'liveSegQueue'`);
-      }
+        debug(`[${this.sessionId}]: Pushed segment (${liveSegFromLeader.uri ? liveSegFromLeader.uri : "Disc-tag"}) to 'liveSegQueue'`);
+      });
       if (incrementDiscSeqCount) {
         this.discSeqCount++;
       }
-      this.mediaSeqCount++;
     }
+    let prevVal = this.mediaSeqCount;
+    this.mediaSeqCount += newSegCount;
+    debug(`[${this.sessionId}]: Incrementing Mseq Count from [${prevVal}] -> [${this.mediaSeqCount}]`);
     debug(`[${this.sessionId}]: Finished updating all Follower's Counts and Segment Queues!`);
   }
 
@@ -810,7 +824,7 @@ class SessionLive {
       }
 
       // [LASTLY]: LEADER does this for respawned-FOLLOWERS' sake.
-      if (this.firstTime) {
+      if (this.firstTime && this.allowedToSet) {
         // Buy some time for followers (NOT Respawned) to fetch their own L.S m3u8.
         await timer(1000); // maybe remove
         const firstCounts = {
@@ -1004,16 +1018,17 @@ class SessionLive {
         cueData["assetData"] = attributes["assetData"];
       }
       if ("daterange" in attributes) {
-        if(!daterangeData) {
-          daterangeData = {}
+        if (!daterangeData) {
+          daterangeData = {};
         }
-        daterangeData = {
-          id: attributes["daterange"]["ID"],
-          "start-date": attributes["daterange"]["START-DATE"],
-          "planned-duration": parseFloat(
-            attributes["daterange"]["PLANNED-DURATION"]
-          ),
-        };
+        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")) {
@@ -1034,6 +1049,7 @@ class SessionLive {
         this.liveSegQueue[liveTargetBandwidth].map((seg) => {if (seg.uri) { segCount++ }});
         debug(`[${this.sessionId}]: size of queue=${segCount}_targetNumseg=${this.targetNumSeg}`);
         if (segCount > this.targetNumSeg) {
+          debug(`[${this.sessionId}]: liveTargetBandwidth=${liveTargetBandwidth}_seg=${JSON.stringify(seg,null,2)}`);
           seg = this.liveSegQueue[liveTargetBandwidth].shift();
           if (seg) {
             if (seg.discontinuity) {
@@ -1041,6 +1057,7 @@ class SessionLive {
               amountRemovedDiscSeqs++;
             }
           }
+          debug(`[${this.sessionId}]: After Shifting -> size of queue=${segCount}_targetNumseg=${this.targetNumSeg}`);
         }
       }
     }
@@ -1155,9 +1172,12 @@ class SessionLive {
           }
         }
       }
+      if (seg.datetime) {
+        m3u8 += `#EXT-X-PROGRAM-DATE-TIME:${seg.datetime}\n`;
+      }
       if (seg.daterange) {
         const dateRangeAttributes = Object.keys(seg.daterange).map(key => daterangeAttribute(key, seg.daterange[key])).join(',');
-        if (seg.daterange['start-date']) {
+        if (!seg.datetime && seg.daterange['start-date']) {
           m3u8 += "#EXT-X-PROGRAM-DATE-TIME:" + seg.daterange['start-date'] + "\n";
         }
         m3u8 += "#EXT-X-DATERANGE:" + dateRangeAttributes + "\n";

package/engine/stream_switcher.js

@@ -30,6 +30,7 @@ class StreamSwitcher {
     this.timeDiff = null;
     this.abortTimeStamp = null;
 
+
     if (config) {
       if (config.sessionId) {
         this.sessionId = config.sessionId;
@@ -50,6 +51,26 @@ class StreamSwitcher {
     return this.eventId;
   }
 
+  async abortLiveFeed(session, sessionLive, message) {
+    if (this.streamTypeLive) {
+      let status = null;
+      debug(`[${this.sessionId}]: Abort Live Stream! Reason: ${message}`);
+      try {
+        this.abortTimeStamp = Date.now();
+        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}`);
+        throw new Error(err);
+      }
+    }
+  }
+
   /**
    *
    * @param {Session} session The VOD2Live Session object.
@@ -57,6 +78,7 @@ class StreamSwitcher {
    * @returns A bool, true if streamSwitchManager contains current Live event to be played else false.
    */
   async streamSwitcher(session, sessionLive) {
+    let status = null;
     if (!this.streamSwitchManager) {
       debug(`[${this.sessionId}]: No streamSwitchManager available`);
       return false;
@@ -65,11 +87,28 @@ class StreamSwitcher {
       debug(`[${this.sessionId}]: streamSwitcher is currently busy`);
       return null;
     }
-    let status = null;
+    // Handle Complete Storage Reset
+    let sessionState = await session._sessionState.get("state");
+    if (sessionState === 1 || !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;
+      }
+      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 tsNow = Date.now();
     const strmSchedule = await this.streamSwitchManager.getSchedule(this.sessionId);
-    const schedule = strmSchedule.filter((obj) => obj.end_time > tsNow);   
+    const schedule = strmSchedule.filter((obj) => obj.end_time > tsNow);
     if (schedule.length === 0 && this.streamTypeLive) {
       status = await this._initSwitching(
         SwitcherState.LIVE_TO_V2L,
@@ -102,47 +141,54 @@ class StreamSwitcher {
     let tries = 0;
     let validURI = false;
     while (!validURI && tries < MAX_FAILS) {
-      debug(`[${this.sessionId}]: Switcher is validating Master URI... (tries left=${MAX_FAILS - tries})`);
+      debug(
+        `[${
+          this.sessionId
+        }]: Switcher is validating Master URI... (tries left=${
+          MAX_FAILS - tries
+        })`
+      );
       validURI = await this._validURI(scheduleObj.uri);
       tries++;
     }
     if (!validURI) {
       debug(`[${this.sessionId}]: Unreachable URI: [${scheduleObj.uri}]`);
       if (this.streamTypeLive) {
-        debug(`[${this.sessionId}]: Abort Live Stream! Switching back to VOD2Live due to unreachable URI`);
-        this.abortTimeStamp = Date.now();
-        status = await this._initSwitching(
-          SwitcherState.LIVE_TO_V2L,
+        await this.abortLiveFeed(
           session,
           sessionLive,
-          null
+          "Switching back to VOD2Live due to unreachable URI"
         );
-        return status;
       }
       return false;
     }
     debug(`[${this.sessionId}]: ....Master URI -> VALID`);
 
-
-    if (this.abortTimeStamp && (tsNow - this.abortTimeStamp) <= 10000) {
+    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`);
+      debug(
+        `[${this.sessionId}]: Waiting [${
+          10000 - (tsNow - this.abortTimeStamp)
+        }ms] before switching back to Live due to unreachable URI`
+      );
       return false;
-    } 
+    }
     this.abortTimeStamp = null;
 
     if (this.streamTypeLive) {
-      if (tsNow >= scheduleObj.start_time && this.eventId !== scheduleObj.eventId) {
+      if (
+        tsNow >= scheduleObj.start_time &&
+        this.eventId !== scheduleObj.eventId
+      ) {
         if (scheduleObj.type === StreamType.LIVE) {
-          status =  await this._initSwitching(
+          status = await this._initSwitching(
             SwitcherState.LIVE_TO_LIVE,
             session,
             sessionLive,
             scheduleObj
           );
           return status;
-
         }
         status = await this._initSwitching(
           SwitcherState.LIVE_TO_VOD,
@@ -153,7 +199,11 @@ class StreamSwitcher {
         return status;
       }
     }
-    if (tsNow >= scheduleObj.start_time && tsNow < scheduleObj.end_time && (scheduleObj.end_time - tsNow) > 10000) {
+    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(
@@ -168,7 +218,9 @@ class StreamSwitcher {
       }
       if (!this.streamTypeLive) {
         if (!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}]`
+          );
           return false;
         }
         if (this.eventId !== scheduleObj.eventId) {
@@ -198,133 +250,205 @@ class StreamSwitcher {
 
     switch (state) {
       case SwitcherState.V2L_TO_LIVE:
-        debug(`[${this.sessionId}]: [ INIT Switching from V2L->LIVE ]`);
-        this.eventId = scheduleObj.eventId;
-        currVodCounts = await session.getCurrentMediaAndDiscSequenceCount();
-        currVodSegments = await session.getCurrentMediaSequenceSegments();
-
-        // 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.setCurrentMediaSequenceSegments(currVodSegments);
-        liveUri = await sessionLive.setLiveUri(scheduleObj.uri);
-
-        if (!liveUri) {
-          debug(`[${this.sessionId}]: [ ERROR Switching from V2L->LIVE ]`);
-          this.working = false;
-          this.eventId = null;
-          return false;
-        }
+        try {
+          debug(`[${this.sessionId}]: [ INIT Switching from V2L->LIVE ]`);
+          this.eventId = scheduleObj.eventId;
+          currVodCounts = await session.getCurrentMediaAndDiscSequenceCount();
+          currVodSegments = await session.getCurrentMediaSequenceSegments();
+
+          // 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.setCurrentMediaSequenceSegments(currVodSegments);
+          liveUri = await sessionLive.setLiveUri(scheduleObj.uri);
 
-        this.working = false;
-        this.streamTypeLive = true;
-        debug(`[${this.sessionId}]: [ Switched from V2L->LIVE ]`);
-        return true;
-      case SwitcherState.V2L_TO_VOD:
-        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);
+          if (!liveUri) {
+            debug(`[${this.sessionId}]: [ ERROR Switching from V2L->LIVE ]`);
+            this.working = false;
+            this.eventId = null;
+            return false;
+          }
 
-        if (!eventSegments) {
-          debug(`[${this.sessionId}]: [ ERROR Switching from V2L->VOD ]`);
+          this.working = false;
+          this.streamTypeLive = true;
+          debug(`[${this.sessionId}]: [ Switched from V2L->LIVE ]`);
+          return true;
+        } catch (err) {
+          this.streamTypeLive = false;
           this.working = false;
           this.eventId = null;
-          return false;
+          debug(`[${this.sessionId}]: [ ERROR Switching from V2L->LIVE ]`);
+          throw new Error(err);
         }
 
-        await session.setCurrentMediaAndDiscSequenceCount(currVodCounts.mediaSeq, currVodCounts.discSeq);
-        await session.setCurrentMediaSequenceSegments(eventSegments, 0, true);
+      case SwitcherState.V2L_TO_VOD:
+        try {
+          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
+          );
 
-        this.working = false;
-        debug(`[${this.sessionId}]: [ Switched from V2L->VOD ]`);
-        return false;
-      case SwitcherState.LIVE_TO_V2L:
-        debug(`[${this.sessionId}]: [ INIT Switching from LIVE->V2L ]`);
-        this.eventId = null;
-        liveSegments = await sessionLive.getCurrentMediaSequenceSegments();
-        liveCounts = await sessionLive.getCurrentMediaAndDiscSequenceCount();
+          if (!eventSegments) {
+            debug(`[${this.sessionId}]: [ ERROR Switching from V2L->VOD ]`);
+            this.working = false;
+            this.eventId = null;
+            return false;
+          }
 
-        await sessionLive.resetSession();
-        sessionLive.resetLiveStoreAsync(RESET_DELAY); // In parallel
+          await session.setCurrentMediaAndDiscSequenceCount(
+            currVodCounts.mediaSeq,
+            currVodCounts.discSeq
+          );
+          await session.setCurrentMediaSequenceSegments(eventSegments, 0, true);
 
-        if (scheduleObj && !scheduleObj.duration) {
-          debug(`[${this.sessionId}]: Cannot switch VOD. No duration specified for schedule item: [${scheduleObj.assetId}]`);
+          this.working = false;
+          debug(`[${this.sessionId}]: [ Switched from V2L->VOD ]`);
+          return false;
+        } catch (err) {
+          this.streamTypeLive = false;
+          this.working = false;
+          this.eventId = null;
+          debug(`[${this.sessionId}]: [ ERROR Switching from V2L->VOD ]`);
+          throw new Error(err);
         }
+      case SwitcherState.LIVE_TO_V2L:
+        try {
+          debug(`[${this.sessionId}]: [ INIT Switching from LIVE->V2L ]`);
+          this.eventId = null;
+          liveSegments = await sessionLive.getCurrentMediaSequenceSegments();
+          liveCounts = await sessionLive.getCurrentMediaAndDiscSequenceCount();
+
+          await sessionLive.resetSession();
+          sessionLive.resetLiveStoreAsync(RESET_DELAY); // In parallel
+
+          if (scheduleObj && !scheduleObj.duration) {
+            debug(
+              `[${this.sessionId}]: Cannot switch VOD. No duration specified for schedule item: [${scheduleObj.assetId}]`
+            );
+          }
+
+          if (this._isEmpty(liveSegments.currMseqSegs)) {
+            this.working = false;
+            this.streamTypeLive = false;
+            debug(`[${this.sessionId}]: [ Switched from LIVE->V2L ]`);
+            return false;
+          }
+
+          await session.setCurrentMediaSequenceSegments(
+            liveSegments.currMseqSegs,
+            liveSegments.segCount
+          );
+          await session.setCurrentMediaAndDiscSequenceCount(
+            liveCounts.mediaSeq,
+            liveCounts.discSeq
+          );
 
-        if (this._isEmpty(liveSegments.currMseqSegs)) {
           this.working = false;
           this.streamTypeLive = false;
           debug(`[${this.sessionId}]: [ Switched from LIVE->V2L ]`);
-          return false;;
+          return false;
+        } catch (err) {
+          this.streamTypeLive = false;
+          this.working = false;
+          this.eventId = null;
+          debug(`[${this.sessionId}]: [ ERROR Switching from LIVE->V2L ]`);
+          throw new Error(err);
         }
-
-        await session.setCurrentMediaSequenceSegments(liveSegments.currMseqSegs, liveSegments.segCount);
-        await session.setCurrentMediaAndDiscSequenceCount(liveCounts.mediaSeq, liveCounts.discSeq);
-        
-
-        this.working = false;
-        this.streamTypeLive = false;
-        debug(`[${this.sessionId}]: [ Switched from LIVE->V2L ]`);
-        return false;
       case SwitcherState.LIVE_TO_VOD:
-        debug(`[${this.sessionId}]: INIT Switching from LIVE->VOD`);
-        // TODO: Not yet fully tested/supported
-        this.eventId = scheduleObj.eventId;
-        liveSegments = await sessionLive.getCurrentMediaSequenceSegments();
-        liveCounts = await sessionLive.getCurrentMediaAndDiscSequenceCount();
-        await sessionLive.resetSession();
-        sessionLive.resetLiveStoreAsync(RESET_DELAY); // In parallel
-
-        eventSegments = await session.getTruncatedVodSegments(scheduleObj.uri, scheduleObj.duration / 1000);
-        if (!eventSegments) {
-          debug(`[${this.sessionId}]: [ ERROR Switching from LIVE->VOD ]`);
+        try {
+          debug(`[${this.sessionId}]: INIT Switching from LIVE->VOD`);
+          // TODO: Not yet fully tested/supported
+          this.eventId = scheduleObj.eventId;
+          liveSegments = await sessionLive.getCurrentMediaSequenceSegments();
+          liveCounts = await sessionLive.getCurrentMediaAndDiscSequenceCount();
+          await sessionLive.resetSession();
+          sessionLive.resetLiveStoreAsync(RESET_DELAY); // In parallel
+
+          eventSegments = await session.getTruncatedVodSegments(
+            scheduleObj.uri,
+            scheduleObj.duration / 1000
+          );
+          if (!eventSegments) {
+            debug(`[${this.sessionId}]: [ ERROR Switching from LIVE->VOD ]`);
+            this.streamTypeLive = false;
+            this.working = false;
+            this.eventId = null;
+            return false;
+          }
+
+          await session.setCurrentMediaAndDiscSequenceCount(
+            liveCounts.mediaSeq - 1,
+            liveCounts.discSeq - 1
+          );
+          await session.setCurrentMediaSequenceSegments(
+            liveSegments.currMseqSegs,
+            liveSegments.segCount
+          );
+          await session.setCurrentMediaSequenceSegments(eventSegments, 0, true);
+
+          this.working = false;
+          this.streamTypeLive = false;
+          debug(`[${this.sessionId}]: Switched from LIVE->VOD`);
+          return false;
+        } catch (err) {
           this.streamTypeLive = false;
           this.working = false;
           this.eventId = null;
-          return false;
+          debug(`[${this.sessionId}]: [ ERROR Switching from LIVE->VOD ]`);
+          throw new Error(err);
         }
-
-        await session.setCurrentMediaAndDiscSequenceCount(liveCounts.mediaSeq - 1, liveCounts.discSeq - 1);
-        await session.setCurrentMediaSequenceSegments(liveSegments.currMseqSegs, liveSegments.segCount);
-        await session.setCurrentMediaSequenceSegments(eventSegments, 0, true);
-
-        this.working = false;
-        this.streamTypeLive = false;
-        debug(`[${this.sessionId}]: Switched from LIVE->VOD`);
-        return false;
       case SwitcherState.LIVE_TO_LIVE:
-        debug(`[${this.sessionId}]: INIT Switching from LIVE->LIVE`);
-        // TODO: Not yet fully tested/supported
-        this.eventId = scheduleObj.eventId;
-        eventSegments = await sessionLive.getCurrentMediaSequenceSegments();
-        currLiveCounts = await sessionLive.getCurrentMediaAndDiscSequenceCount();
-
-        await sessionLive.resetSession();
-        await sessionLive.resetLiveStoreAsync(0);
+        try {
+          debug(`[${this.sessionId}]: INIT Switching from LIVE->LIVE`);
+          // TODO: Not yet fully tested/supported
+          this.eventId = scheduleObj.eventId;
+          eventSegments = await sessionLive.getCurrentMediaSequenceSegments();
+          currLiveCounts =
+            await sessionLive.getCurrentMediaAndDiscSequenceCount();
+
+          await sessionLive.resetSession();
+          await sessionLive.resetLiveStoreAsync(0);
+
+          await sessionLive.setCurrentMediaAndDiscSequenceCount(
+            currLiveCounts.mediaSeq,
+            currLiveCounts.discSeq
+          );
+          await sessionLive.setCurrentMediaSequenceSegments(
+            eventSegments.currMseqSegs
+          );
+          liveUri = await sessionLive.setLiveUri(scheduleObj.uri);
 
-        await sessionLive.setCurrentMediaAndDiscSequenceCount(currLiveCounts.mediaSeq, currLiveCounts.discSeq);
-        await sessionLive.setCurrentMediaSequenceSegments(eventSegments.currMseqSegs);
-        liveUri = await sessionLive.setLiveUri(scheduleObj.uri);
+          if (!liveUri) {
+            debug(`[${this.sessionId}]: [ ERROR Switching from LIVE->LIVE ]`);
+            this.streamTypeLive = false;
+            this.working = false;
+            this.eventId = null;
+            return false;
+          }
 
-        if (!liveUri) {
-          debug(`[${this.sessionId}]: [ ERROR Switching from LIVE->LIVE ]`);
+          this.working = false;
+          debug(`[${this.sessionId}]: Switched from LIVE->LIVE`);
+          return true;
+        } catch (err) {
           this.streamTypeLive = false;
           this.working = false;
           this.eventId = null;
-          return false;
+          debug(`[${this.sessionId}]: [ ERROR Switching from LIVE->LIVE ]`);
+          throw new Error(err);
         }
-
-        this.working = false;
-        debug(`[${this.sessionId}]: Switched from LIVE->LIVE`);
-        return true;
       default:
         debug(`[${this.sessionId}]: SwitcherState [${state}] not implemented`);
         this.streamTypeLive = false;
         this.working = false;
         this.eventId = null;
-        return false;;
+        return false;
     }
   }
 
@@ -352,10 +476,14 @@ 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);

package/package.json

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

package/server.js

@@ -100,4 +100,4 @@ const engineOptions = {
 
 const engine = new ChannelEngine(refAssetManager, engineOptions);
 engine.start();
-engine.listen(process.env.PORT || 8000);
+engine.listen(process.env.port || 8000);