eyevinn-channel-engine 3.1.7 → 3.2.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (9) hide show
  1. package/engine/server.js +7 -4
  2. package/engine/session.js +206 -90
  3. package/engine/session_live.js +86 -26
  4. package/engine/session_state.js +9 -2
  5. package/engine/stream_switcher.js +13 -6
  6. package/engine/util.js +30 -0
  7. package/package.json +1 -1
  8. package/spec/engine/init_switching_spec.js +118 -153
  9. package/spec/engine/stream_switcher_spec.js +91 -68
package/spec/engine/stream_switcher_spec.js CHANGED
@@ -219,37 +219,42 @@ describe("The Stream Switcher", () => {
219
219
 
220
220
  it("should return false if no StreamSwitchManager was given.", async () => {
221
221
  const assetMgr = new TestAssetManager();
222
+ const testStreamSwitcher = new StreamSwitcher();
222
223
  const session = new Session(assetMgr, {sessionId: "1"}, sessionStore);
223
224
  const sessionLive = new SessionLive({sessionId: "1"}, sessionLiveStore);
225
+
224
226
  await session.initAsync();
225
227
  await session.incrementAsync();
226
228
  await sessionLive.initAsync();
227
229
 
228
- let TestStreamSwitcher = new StreamSwitcher();
229
- expect(await TestStreamSwitcher.streamSwitcher(session, sessionLive)).toBe(false);
230
- expect(TestStreamSwitcher.getEventId()).toBe(null);
230
+ expect(await testStreamSwitcher.streamSwitcher(session, sessionLive)).toBe(false);
231
+ expect(testStreamSwitcher.getEventId()).toBe(null);
231
232
  });
232
233
 
233
234
  it("should validate uri and switch back to linear-vod (session) from event-livestream (sessionLive) if uri is unreachable", async () => {
234
235
  const switchMgr = new TestSwitchManager(0);
236
+ const testStreamSwitcher = new StreamSwitcher({streamSwitchManager: switchMgr});
235
237
  const assetMgr = new TestAssetManager();
236
238
  const session = new Session(assetMgr, {sessionId: "1"}, sessionStore);
237
239
  const sessionLive = new SessionLive({sessionId: "1"}, sessionLiveStore);
238
240
  spyOn(sessionLive, "resetLiveStoreAsync").and.callFake( () => true );
239
241
  spyOn(sessionLive, "resetSession").and.callFake( () => true );
240
242
  spyOn(sessionLive, "getCurrentMediaSequenceSegments").and.returnValue({ currMseqSegs: mockLiveSegments, segCount: 8 });
243
+ spyOn(session, "setCurrentMediaSequenceSegments").and.returnValue(true);
244
+ spyOn(session, "setCurrentMediaAndDiscSequenceCount").and.returnValue(true);
245
+
241
246
  await session.initAsync();
242
247
  await session.incrementAsync();
243
248
  await sessionLive.initAsync();
244
249
  sessionLive.startPlayheadAsync();
245
250
 
246
- let TestStreamSwitcher = new StreamSwitcher({streamSwitchManager: switchMgr});
247
- expect(await TestStreamSwitcher.streamSwitcher(session, sessionLive)).toBe(false);
248
- expect(TestStreamSwitcher.getEventId()).toBe(null);
251
+
252
+ expect(await testStreamSwitcher.streamSwitcher(session, sessionLive)).toBe(false);
253
+ expect(testStreamSwitcher.getEventId()).toBe(null);
249
254
  jasmine.clock().mockDate(tsNow);
250
255
  jasmine.clock().tick((25 * 1000));
251
- expect(await TestStreamSwitcher.streamSwitcher(session, sessionLive)).toBe(true);
252
- expect(TestStreamSwitcher.getEventId()).toBe("live-0");
256
+ expect(await testStreamSwitcher.streamSwitcher(session, sessionLive)).toBe(true);
257
+ expect(testStreamSwitcher.getEventId()).toBe("live-0");
253
258
 
254
259
  jasmine.clock().tick((25 * 1000) + (10 * 1000));
255
260
  spyOn(switchMgr, "getSchedule").and.returnValue([{
@@ -260,204 +265,222 @@ describe("The Stream Switcher", () => {
260
265
  end_time: tsNow + 1 * 60 * 1000,
261
266
  uri: "https://www.google.com/nothere",
262
267
  }]);
263
- expect(await TestStreamSwitcher.streamSwitcher(session, sessionLive)).toBe(false);
264
- expect(TestStreamSwitcher.getEventId()).toEqual(null);
268
+ expect(await testStreamSwitcher.streamSwitcher(session, sessionLive)).toBe(false);
269
+ expect(testStreamSwitcher.getEventId()).toEqual(null);
265
270
  });
266
271
 
267
272
  it("should switch from linear-vod (session) to event-livestream (sessionLive) according to schedule", async () => {
268
273
  const switchMgr = new TestSwitchManager(0);
274
+ const testStreamSwitcher = new StreamSwitcher({streamSwitchManager: switchMgr});
269
275
  const assetMgr = new TestAssetManager();
270
276
  const session = new Session(assetMgr, {sessionId: "1"}, sessionStore);
271
277
  const sessionLive = new SessionLive({sessionId: "1"}, sessionLiveStore);
272
278
  spyOn(sessionLive, "resetLiveStoreAsync").and.callFake( () => true );
273
279
  spyOn(sessionLive, "resetSession").and.callFake( () => true );
274
280
  spyOn(sessionLive, "getCurrentMediaSequenceSegments").and.returnValue({ currMseqSegs: mockLiveSegments, segCount: 8 });
281
+
275
282
  await session.initAsync();
276
283
  await session.incrementAsync();
277
284
  await sessionLive.initAsync();
278
285
  sessionLive.startPlayheadAsync();
279
286
 
280
- let TestStreamSwitcher = new StreamSwitcher({streamSwitchManager: switchMgr});
281
- expect(await TestStreamSwitcher.streamSwitcher(session, sessionLive)).toBe(false);
282
- expect(TestStreamSwitcher.getEventId()).toBe(null);
287
+ expect(await testStreamSwitcher.streamSwitcher(session, sessionLive)).toBe(false);
288
+ expect(testStreamSwitcher.getEventId()).toBe(null);
283
289
  jasmine.clock().mockDate(tsNow);
284
290
  jasmine.clock().tick((25 * 1000));
285
- expect(await TestStreamSwitcher.streamSwitcher(session, sessionLive)).toBe(true);
286
- expect(TestStreamSwitcher.getEventId()).toBe("live-0");
291
+ expect(await testStreamSwitcher.streamSwitcher(session, sessionLive)).toBe(true);
292
+ expect(testStreamSwitcher.getEventId()).toBe("live-0");
287
293
  });
288
294
 
289
295
  it("should switch from event-livestream (sessionLive) to linear-vod (session) according to schedule", async () => {
290
296
  const switchMgr = new TestSwitchManager(0);
297
+ const testStreamSwitcher = new StreamSwitcher({streamSwitchManager: switchMgr});
291
298
  const assetMgr = new TestAssetManager();
292
299
  const session = new Session(assetMgr, {sessionId: "1"}, sessionStore);
293
300
  const sessionLive = new SessionLive({sessionId: "1"}, sessionLiveStore);
301
+ spyOn(sessionLive, "resetLiveStoreAsync").and.callFake( () => true );
302
+ spyOn(sessionLive, "resetSession").and.callFake( () => true );
303
+ spyOn(sessionLive, "getCurrentMediaSequenceSegments").and.returnValue({ currMseqSegs: mockLiveSegments, segCount: 8 });
304
+ spyOn(session, "setCurrentMediaSequenceSegments").and.returnValue(true);
305
+ spyOn(session, "setCurrentMediaAndDiscSequenceCount").and.returnValue(true);
294
306
 
295
307
  await session.initAsync();
296
308
  await session.incrementAsync();
297
309
  await sessionLive.initAsync();
298
310
  sessionLive.startPlayheadAsync();
299
- spyOn(sessionLive, "resetLiveStoreAsync").and.callFake( () => true );
300
- spyOn(sessionLive, "resetSession").and.callFake( () => true );
301
- spyOn(sessionLive, "getCurrentMediaSequenceSegments").and.returnValue({ currMseqSegs: mockLiveSegments, segCount: 8 });
302
- let TestStreamSwitcher = new StreamSwitcher({streamSwitchManager: switchMgr});
303
311
 
304
312
  jasmine.clock().mockDate(tsNow);
305
313
  jasmine.clock().tick((25 * 1000));
306
- expect(await TestStreamSwitcher.streamSwitcher(session, sessionLive)).toBe(true);
307
- expect(TestStreamSwitcher.getEventId()).toBe("live-0");
314
+ expect(await testStreamSwitcher.streamSwitcher(session, sessionLive)).toBe(true);
315
+ expect(testStreamSwitcher.getEventId()).toBe("live-0");
308
316
  jasmine.clock().tick((60 * 1000 + 25 * 1000));
309
- expect(await TestStreamSwitcher.streamSwitcher(session, sessionLive)).toBe(false);
310
- expect(TestStreamSwitcher.getEventId()).toBe(null);
317
+ expect(await testStreamSwitcher.streamSwitcher(session, sessionLive)).toBe(false);
318
+ expect(testStreamSwitcher.getEventId()).toBe(null);
311
319
  });
312
320
 
313
321
  it("should switch from linear-vod (session) to event-vod (session) according to schedule", async () => {
314
322
  const switchMgr = new TestSwitchManager(1);
323
+ const testStreamSwitcher = new StreamSwitcher({streamSwitchManager: switchMgr});
315
324
  const assetMgr = new TestAssetManager();
316
325
  const session = new Session(assetMgr, {sessionId: "1"}, sessionStore);
326
+ spyOn(session, "setCurrentMediaSequenceSegments").and.returnValue(true);
327
+ spyOn(session, "setCurrentMediaAndDiscSequenceCount").and.returnValue(true);
328
+
317
329
  await session.initAsync();
318
330
  await session.incrementAsync();
319
331
 
320
- let TestStreamSwitcher = new StreamSwitcher({streamSwitchManager: switchMgr});
321
- expect(await TestStreamSwitcher.streamSwitcher(session, null)).toBe(false);
322
- expect(TestStreamSwitcher.getEventId()).toBe(null);
332
+
333
+ expect(await testStreamSwitcher.streamSwitcher(session, null)).toBe(false);
334
+ expect(testStreamSwitcher.getEventId()).toBe(null);
323
335
  jasmine.clock().mockDate(tsNow);
324
336
  jasmine.clock().tick((25 * 1000));
325
- expect(await TestStreamSwitcher.streamSwitcher(session, null)).toBe(false);
326
- expect(TestStreamSwitcher.getEventId()).toBe("vod-0");
337
+ expect(await testStreamSwitcher.streamSwitcher(session, null)).toBe(false);
338
+ expect(testStreamSwitcher.getEventId()).toBe("vod-0");
327
339
  });
328
340
 
329
341
  it("should switch from event-vod (session) to linear-vod (session) according to schedule", async () => {
330
342
  const switchMgr = new TestSwitchManager(1);
343
+ const testStreamSwitcher = new StreamSwitcher({streamSwitchManager: switchMgr});
331
344
  const assetMgr = new TestAssetManager();
332
345
  const session = new Session(assetMgr, {sessionId: "1"}, sessionStore);
346
+ spyOn(session, "setCurrentMediaSequenceSegments").and.returnValue(true);
347
+ spyOn(session, "setCurrentMediaAndDiscSequenceCount").and.returnValue(true);
348
+
333
349
  await session.initAsync();
334
350
  await session.incrementAsync();
335
351
 
336
- let TestStreamSwitcher = new StreamSwitcher({streamSwitchManager: switchMgr});
337
352
  jasmine.clock().mockDate(tsNow);
338
353
  jasmine.clock().tick((25 * 1000));
339
- expect(await TestStreamSwitcher.streamSwitcher(session, null)).toBe(false);
340
- expect(TestStreamSwitcher.getEventId()).toBe("vod-0");
354
+ expect(await testStreamSwitcher.streamSwitcher(session, null)).toBe(false);
355
+ expect(testStreamSwitcher.getEventId()).toBe("vod-0");
341
356
  jasmine.clock().tick((1 + (60 * 1000 + 25 * 1000)));
342
- expect(await TestStreamSwitcher.streamSwitcher(session, null)).toBe(false);
343
- expect(TestStreamSwitcher.getEventId()).toBe(null);
357
+ expect(await testStreamSwitcher.streamSwitcher(session, null)).toBe(false);
358
+ expect(testStreamSwitcher.getEventId()).toBe(null);
344
359
  });
345
360
 
346
361
  it("should not switch from linear-vod (session) to event-vod (session) if duration is not set in schedule", async () => {
347
362
  const switchMgr = new TestSwitchManager(6);
363
+ const testStreamSwitcher = new StreamSwitcher({streamSwitchManager: switchMgr});
348
364
  const assetMgr = new TestAssetManager();
349
365
  const session = new Session(assetMgr, {sessionId: "1"}, sessionStore);
366
+
350
367
  await session.initAsync();
351
368
  await session.incrementAsync();
352
369
 
353
- let TestStreamSwitcher = new StreamSwitcher({streamSwitchManager: switchMgr});
354
370
  jasmine.clock().mockDate(tsNow);
355
371
  jasmine.clock().tick((25 * 1000));
356
- expect(await TestStreamSwitcher.streamSwitcher(session, null)).toBe(false);
357
- expect(TestStreamSwitcher.getEventId()).toBe(null);
372
+ expect(await testStreamSwitcher.streamSwitcher(session, null)).toBe(false);
373
+ expect(testStreamSwitcher.getEventId()).toBe(null);
358
374
  });
359
375
 
360
376
  xit("should switch from linear-vod (session) to event-livestream (sessionLive) according to schedule. " +
361
377
  "\nThen directly to event-vod (session) and finally switch back to linear-vod (session)", async () => {
362
378
  const switchMgr = new TestSwitchManager(2);
379
+ const testStreamSwitcher = new StreamSwitcher({streamSwitchManager: switchMgr});
363
380
  const assetMgr = new TestAssetManager();
364
381
  const session = new Session(assetMgr, {sessionId: "1"}, sessionStore);
365
382
  const sessionLive = new SessionLive({sessionId: "1"}, sessionLiveStore);
366
383
  spyOn(sessionLive, "_loadAllMediaManifests").and.returnValue(mockLiveSegments);
384
+
367
385
  await session.initAsync();
368
386
  await session.incrementAsync();
369
387
  sessionLive.initAsync();
370
- const TestStreamSwitcher = new StreamSwitcher({streamSwitchManager: switchMgr});
371
388
 
372
389
  jasmine.clock().mockDate(tsNow);
373
390
  jasmine.clock().tick((25 * 1000));
374
- expect(await TestStreamSwitcher.streamSwitcher(session, sessionLive)).toBe(true);
375
- expect(TestStreamSwitcher.getEventId()).toBe("live-1");
391
+ expect(await testStreamSwitcher.streamSwitcher(session, sessionLive)).toBe(true);
392
+ expect(testStreamSwitcher.getEventId()).toBe("live-1");
376
393
  jasmine.clock().tick((1 + (60 * 1000 + 20 * 1000)));
377
394
  await sessionLive.getCurrentMediaManifestAsync(180000);
378
- expect(await TestStreamSwitcher.streamSwitcher(session, sessionLive)).toBe(false);
379
- expect(TestStreamSwitcher.getEventId()).toBe("vod-1");
395
+ expect(await testStreamSwitcher.streamSwitcher(session, sessionLive)).toBe(false);
396
+ expect(testStreamSwitcher.getEventId()).toBe("vod-1");
380
397
  jasmine.clock().tick((1 + (60 * 1000 + 20 * 1000)) + (60*1000));
381
- expect(await TestStreamSwitcher.streamSwitcher(session, sessionLive)).toBe(false);
382
- expect(TestStreamSwitcher.getEventId()).toBe(null);
398
+ expect(await testStreamSwitcher.streamSwitcher(session, sessionLive)).toBe(false);
399
+ expect(testStreamSwitcher.getEventId()).toBe(null);
383
400
  });
384
401
 
385
402
  xit("should switch from linear-vod (session) to event-livestream (sessionLive) according to schedule. " +
386
403
  "\nThen directly to 2nd event-livestream (sessionLive) and finally switch back to linear-vod (session)", async () => {
387
404
  const switchMgr = new TestSwitchManager(3);
405
+ const testStreamSwitcher = new StreamSwitcher({streamSwitchManager: switchMgr});
388
406
  const assetMgr = new TestAssetManager();
389
407
  const session = new Session(assetMgr, {sessionId: "1"}, sessionStore);
390
408
  const sessionLive = new SessionLive({sessionId: "1"}, sessionLiveStore);
391
409
  spyOn(sessionLive, "_loadAllMediaManifests").and.returnValue(mockLiveSegments);
410
+
392
411
  await session.initAsync();
393
412
  await session.incrementAsync();
394
413
  await sessionLive.initAsync();
395
- let TestStreamSwitcher = new StreamSwitcher({streamSwitchManager: switchMgr});
396
414
 
397
415
  jasmine.clock().mockDate(tsNow);
398
416
  jasmine.clock().tick((25 * 1000));
399
- expect(await TestStreamSwitcher.streamSwitcher(session, sessionLive)).toBe(true);
400
- expect(TestStreamSwitcher.getEventId()).toBe("live-2");
417
+ expect(await testStreamSwitcher.streamSwitcher(session, sessionLive)).toBe(true);
418
+ expect(testStreamSwitcher.getEventId()).toBe("live-2");
401
419
  jasmine.clock().tick((1 + (60 * 1000 + 20 * 1000)));
402
420
  await sessionLive.getCurrentMediaManifestAsync(180000);
403
- expect(await TestStreamSwitcher.streamSwitcher(session, sessionLive)).toBe(true);
404
- expect(TestStreamSwitcher.getEventId()).toBe("live-3");
421
+ expect(await testStreamSwitcher.streamSwitcher(session, sessionLive)).toBe(true);
422
+ expect(testStreamSwitcher.getEventId()).toBe("live-3");
405
423
  jasmine.clock().tick((1 + (60 * 1000 + 20 * 1000)) + (60*1000));
406
424
  await sessionLive.getCurrentMediaManifestAsync(180000);
407
- expect(await TestStreamSwitcher.streamSwitcher(session, sessionLive)).toBe(false);
408
- expect(TestStreamSwitcher.getEventId()).toBe(null);
425
+ expect(await testStreamSwitcher.streamSwitcher(session, sessionLive)).toBe(false);
426
+ expect(testStreamSwitcher.getEventId()).toBe(null);
409
427
  });
410
428
 
411
429
  it("should switch from linear-vod (session) to event-vod (session) according to schedule. " +
412
430
  "\nThen directly to event-livestream (sessionLive) and finally switch back to linear-vod (session)", async () => {
413
431
  const switchMgr = new TestSwitchManager(4);
432
+ const testStreamSwitcher = new StreamSwitcher({streamSwitchManager: switchMgr});
414
433
  const assetMgr = new TestAssetManager();
415
434
  const session = new Session(assetMgr, {sessionId: "1"}, sessionStore);
416
435
  const sessionLive = new SessionLive({sessionId: "1"}, sessionLiveStore);
436
+ spyOn(sessionLive, "resetLiveStoreAsync").and.callFake( () => true );
437
+ spyOn(sessionLive, "resetSession").and.callFake( () => true );
438
+ spyOn(sessionLive, "getCurrentMediaSequenceSegments").and.returnValue({ currMseqSegs: mockLiveSegments, segCount: 8 });
439
+ spyOn(session, "setCurrentMediaSequenceSegments").and.returnValue(true);
440
+ spyOn(session, "setCurrentMediaAndDiscSequenceCount").and.returnValue(true);
417
441
 
418
442
  await session.initAsync();
419
443
  await session.incrementAsync();
420
444
  await sessionLive.initAsync();
421
- spyOn(sessionLive, "resetLiveStoreAsync").and.callFake( () => true );
422
- spyOn(sessionLive, "resetSession").and.callFake( () => true );
423
- spyOn(sessionLive, "getCurrentMediaSequenceSegments").and.returnValue({ currMseqSegs: mockLiveSegments, segCount: 8 });
424
- sessionLive.startPlayheadAsync();
425
445
 
426
- const TestStreamSwitcher = new StreamSwitcher({streamSwitchManager: switchMgr});
446
+ sessionLive.startPlayheadAsync();
427
447
 
428
448
  jasmine.clock().mockDate(tsNow);
429
449
  jasmine.clock().tick((25 * 1000));
430
- expect(await TestStreamSwitcher.streamSwitcher(session, sessionLive)).toBe(false);
431
- expect(TestStreamSwitcher.getEventId()).toBe("vod-2");
450
+ expect(await testStreamSwitcher.streamSwitcher(session, sessionLive)).toBe(false);
451
+ expect(testStreamSwitcher.getEventId()).toBe("vod-2");
432
452
  jasmine.clock().tick((1 + (60 * 1000 + 20 * 1000)));
433
- expect(await TestStreamSwitcher.streamSwitcher(session, sessionLive)).toBe(true);
434
- expect(TestStreamSwitcher.getEventId()).toBe("live-4");
453
+ expect(await testStreamSwitcher.streamSwitcher(session, sessionLive)).toBe(true);
454
+ expect(testStreamSwitcher.getEventId()).toBe("live-4");
435
455
  jasmine.clock().tick((1 + (60 * 1000 + 20 * 1000)) + (60*1000));
436
- expect(await TestStreamSwitcher.streamSwitcher(session, sessionLive)).toBe(false);
437
- expect(TestStreamSwitcher.getEventId()).toBe(null);
456
+ expect(await testStreamSwitcher.streamSwitcher(session, sessionLive)).toBe(false);
457
+ expect(testStreamSwitcher.getEventId()).toBe(null);
438
458
  });
439
459
 
440
460
  it("should switch from linear-vod (session) to event-vod (session) according to schedule. " +
441
461
  "\nThen directly to 2nd event-vod (session) and finally switch back to linear-vod (session)", async () => {
442
462
  const switchMgr = new TestSwitchManager(5);
463
+ const testStreamSwitcher = new StreamSwitcher({streamSwitchManager: switchMgr});
443
464
  const assetMgr = new TestAssetManager();
444
465
  const session = new Session(assetMgr, {sessionId: "1"}, sessionStore);
445
466
  const sessionLive = new SessionLive({sessionId: "1"}, sessionLiveStore);
446
467
  spyOn(sessionLive, "_loadAllMediaManifests").and.returnValue(mockLiveSegments);
468
+ spyOn(session, "setCurrentMediaSequenceSegments").and.returnValue(true);
469
+ spyOn(session, "setCurrentMediaAndDiscSequenceCount").and.returnValue(true);
470
+
447
471
  await session.initAsync();
448
472
  await session.incrementAsync();
449
473
  await sessionLive.initAsync();
450
- let TestStreamSwitcher = new StreamSwitcher({streamSwitchManager: switchMgr});
451
474
 
452
475
  jasmine.clock().mockDate(tsNow);
453
476
  jasmine.clock().tick((25 * 1000));
454
- expect(await TestStreamSwitcher.streamSwitcher(session, sessionLive)).toBe(false);
455
- expect(TestStreamSwitcher.getEventId()).toBe("vod-3");
477
+ expect(await testStreamSwitcher.streamSwitcher(session, sessionLive)).toBe(false);
478
+ expect(testStreamSwitcher.getEventId()).toBe("vod-3");
456
479
  jasmine.clock().tick((1 + (60 * 1000 + 20 * 1000)));
457
- expect(await TestStreamSwitcher.streamSwitcher(session, sessionLive)).toBe(false);
458
- expect(TestStreamSwitcher.getEventId()).toBe("vod-4");
480
+ expect(await testStreamSwitcher.streamSwitcher(session, sessionLive)).toBe(false);
481
+ expect(testStreamSwitcher.getEventId()).toBe("vod-4");
459
482
  jasmine.clock().tick((1 + (60 * 1000 + 20 * 1000)) + (60*1000));
460
- expect(await TestStreamSwitcher.streamSwitcher(session, sessionLive)).toBe(false);
461
- expect(TestStreamSwitcher.getEventId()).toBe(null);
483
+ expect(await testStreamSwitcher.streamSwitcher(session, sessionLive)).toBe(false);
484
+ expect(testStreamSwitcher.getEventId()).toBe(null);
462
485
  });
463
486
  });