Add a setting blacklistExpiryTime to allow baseUrls to be returned to after a failure; refactor ContentSteering TTL to use blacklistController expiry

Author: robertbryer

index.d.ts

@@ -1828,6 +1828,7 @@ export class MediaPlayerSettingClass {
         prioritizeRoleMain?: boolean;
         assumeDefaultRoleAsMain?: boolean;
         selectionModeForInitialTrack?: TrackSelectionMode;
+        blacklistExpiryTime?: number;
         fragmentRequestTimeout?: number;
         fragmentRequestProgressTimeout?: number;
         manifestRequestTimeout?: number;

src/core/Settings.js

@@ -205,6 +205,7 @@ import SwitchRequest from '../streaming/rules/SwitchRequest.js';
  *            prioritizeRoleMain: true,
  *            assumeDefaultRoleAsMain: true,
  *            selectionModeForInitialTrack: Constants.TRACK_SELECTION_MODE_LOWEST_STARTUP_DELAY,
+ *            blacklistExpiryTime: -1,
  *            fragmentRequestTimeout: 20000,
  *            fragmentRequestProgressTimeout: -1,
  *            manifestRequestTimeout: 10000,
@@ -1106,6 +1107,9 @@ import SwitchRequest from '../streaming/rules/SwitchRequest.js';
  * - Constants.TRACK_SELECTION_MODE_WIDEST_RANGE
  * This mode makes the player select the track with a widest range of bitrates.
  *
+ * @property {number} [blacklistExpiryTime=-1]
+ * Time in seconds that a Service Location should be added to the blacklist for. After this time has passed the Service Location will be available for selection when failing over a second time, but it will not actively return to it.
+ * This is ignored when using Content Steering, as the blacklist expiry will be set to the TTL value, and Service Locations may be actively switched back to according to the steering algorithm.
  *
  * @property {number} [fragmentRequestTimeout=20000]
  * Time in milliseconds before timing out on loading a media fragment.
@@ -1340,6 +1344,7 @@ function Settings() {
             prioritizeRoleMain: true,
             assumeDefaultRoleAsMain: true,
             selectionModeForInitialTrack: Constants.TRACK_SELECTION_MODE_LOWEST_STARTUP_DELAY,
+            blacklistExpiryTime: -1,
             fragmentRequestTimeout: 20000,
             fragmentRequestProgressTimeout: -1,
             manifestRequestTimeout: 10000,

src/streaming/controllers/BlacklistController.js

@@ -31,14 +31,17 @@
 
 import FactoryMaker from '../../core/FactoryMaker.js';
 import EventBus from '../../core/EventBus.js';
+import Settings from '../../core/Settings.js';
 
 function BlackListController(config) {
 
     config = config || {};
     let instance;
     let blacklist = [];
+    let blacklistExpiry = null;
 
     const eventBus = EventBus(this.context).getInstance();
+    const settings = Settings(this.context).getInstance();
     const updateEventName = config.updateEventName;
     const addBlacklistEventName = config.addBlacklistEventName;
 
@@ -47,21 +50,29 @@ function BlackListController(config) {
             return false;
         }
 
-        return (blacklist.indexOf(query) !== -1);
+        return (blacklist.findIndex(item => item.entry === query) !== -1);
     }
 
     function add(entry) {
-        if (blacklist.indexOf(entry) !== -1) {
+        if (blacklist.findIndex(item => item.entry === entry) !== -1) {
             return;
         }
 
-        blacklist.push(entry);
+        const expiry = blacklistExpiry || settings.get().streaming.blacklistExpiryTime;
+        if (expiry && expiry > 0) {
+            const timeoutId = setTimeout(() => {
+                remove(entry);
+            }, expiry * 1000);
+            blacklist.push({ entry: entry, timeoutId: timeoutId });
+        } else {
+            blacklist.push({ entry: entry });
+        }
 
         eventBus.trigger(updateEventName, { entry: entry });
     }
 
     function remove(entry) {
-        const index = blacklist.indexOf(entry);
+        const index = blacklist.findIndex(item => item.entry === entry);
         if (index !== -1) {
             blacklist.splice(index, 1)
         }
@@ -71,6 +82,10 @@ function BlackListController(config) {
         add(e.entry);
     }
 
+    function setContentSteeringBlacklistExpiry(seconds) {
+        blacklistExpiry = seconds;
+    }
+
     function setup() {
         if (addBlacklistEventName) {
             eventBus.on(addBlacklistEventName, onAddBlackList, instance);
@@ -81,14 +96,21 @@ function BlackListController(config) {
         if (addBlacklistEventName) {
             eventBus.off(addBlacklistEventName, onAddBlackList, instance);
         }
+        for (const item of blacklist) {
+            if (item.timeoutId) {
+                clearTimeout(item.timeoutId);
+            }
+        }
         blacklist = [];
+        blacklistExpiry = null;
     }
 
     instance = {
         add: add,
         remove: remove,
         contains: contains,
-        reset: reset
+        reset: reset,
+        setContentSteeringBlacklistExpiry: setContentSteeringBlacklistExpiry
     };
 
     setup();

src/streaming/utils/baseUrlResolution/ContentSteeringSelector.js

@@ -32,6 +32,7 @@
 import FactoryMaker from '../../../core/FactoryMaker.js';
 import ContentSteeringController from '../../../dash/controllers/ContentSteeringController.js';
 import EventBus from '../../../core/EventBus.js';
+import MediaPlayerEvents from '../../MediaPlayerEvents.js';
 
 function ContentSteeringSelector() {
 
@@ -53,7 +54,7 @@ function ContentSteeringSelector() {
         if (config.contentSteeringController) {
             contentSteeringController = config.contentSteeringController;
         }
-        eventBus.on(config.addBlacklistEventName, _onAddBlackList, instance);
+        eventBus.on(MediaPlayerEvents.CONTENT_STEERING_REQUEST_COMPLETED, _onContentSteeringRequestCompleted, instance);
     }
 
     function selectBaseUrlIndex(data) {
@@ -100,17 +101,16 @@ function ContentSteeringSelector() {
     }
 
 
-    function _onAddBlackList(e) {
+    function _onContentSteeringRequestCompleted() {
         const currentSteeringResponseData = contentSteeringController.getCurrentSteeringResponseData();
         if (!currentSteeringResponseData) {
             return
         }
-        const entry = e.entry
-        const timer = setTimeout(() => {
-            blacklistController.remove(entry);
-            blacklistResetTimeout.splice(blacklistResetTimeout.indexOf(timer), 1)
-        }, currentSteeringResponseData.ttl * 1000);
-        blacklistResetTimeout.push(timer)
+        if (currentSteeringResponseData.ttl) {
+            blacklistController.setContentSteeringBlacklistExpiry(currentSteeringResponseData.ttl);
+        } else {
+            blacklistController.setContentSteeringBlacklistExpiry(-1);
+        }
     }
 
 

test/unit/test/streaming/streaming.controllers.BlacklistController.js

@@ -1,21 +1,38 @@
 import BlacklistController from '../../../../src/streaming/controllers/BlacklistController.js';
 import EventBus from '../../../../src/core/EventBus.js';
+import Settings from '../../../../src/core/Settings.js';
 import chai from 'chai';
 import spies from 'chai-spies';
+import sinon from 'sinon';
 
 const expect = chai.expect;
 
 chai.use(spies);
 
 describe('BlacklistController', function () {
     const context = {};
+    const settings = Settings(context).getInstance();
     const eventBus = EventBus(context).getInstance();
 
     const SERVICE_LOCATION = 'testServiceLocation';
     const EVENT_NAME = 'blacklistControllerTestEvent';
 
     const defaultConfig = { updateEventName: '' };
 
+    let clock;
+
+    this.beforeEach(() => {
+        clock = sinon.useFakeTimers();
+    });
+
+    this.afterEach(() => {
+        if (clock) {
+            clock.restore();
+            clock = null;
+        }
+        settings.reset();
+    });
+
     it('should return false when calling contains after initialisation', () => {
         const blacklistController = BlacklistController(context).create(defaultConfig);
 
@@ -107,4 +124,30 @@ describe('BlacklistController', function () {
         expect(containsBeforeReset).to.be.true; // jshint ignore:line
         expect(containsAfterReset).to.be.false; // jshint ignore:line
     });
+
+    it('should remove an entry after a content steering TTL blacklist expiry time has passed', () => {
+        const config = { updateEventName: '' };
+        const blacklistController = BlacklistController(context).create(config);
+        blacklistController.setContentSteeringBlacklistExpiry(60);
+
+        blacklistController.add(SERVICE_LOCATION);
+        clock.tick(30 * 1000);
+        expect(blacklistController.contains(SERVICE_LOCATION)).to.be.true;
+
+        clock.tick(30 * 1000);
+        expect(blacklistController.contains(SERVICE_LOCATION)).to.be.false;
+    });
+
+    it('should remove an entry after a blacklist expiry time from settings has passed', () => {
+        const config = { updateEventName: '' };
+        const blacklistController = BlacklistController(context).create(config);
+        settings.update({streaming: { blacklistExpiryTime: 60 }});
+
+        blacklistController.add(SERVICE_LOCATION);
+        clock.tick(30 * 1000);
+        expect(blacklistController.contains(SERVICE_LOCATION)).to.be.true;
+
+        clock.tick(30 * 1000);
+        expect(blacklistController.contains(SERVICE_LOCATION)).to.be.false;
+    });
 });