rx-player 4.0.0-dev.2023092900 → 4.0.0-dev.2023102700

package/dist/_esm5.processed/core/fetchers/utils/schedule_request.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,49 +14,15 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (g && (g = 0, op[0] && (_ = 0)), _) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
-import { CustomLoaderError, isKnownError, NetworkErrorTypes, RequestError, } from "../../../errors";
-import log from "../../../log";
-import cancellableSleep from "../../../utils/cancellable_sleep";
-import getFuzzedDelay from "../../../utils/get_fuzzed_delay";
-import getTimestamp from "../../../utils/monotonic_timestamp";
-import noop from "../../../utils/noop";
-import TaskCanceller from "../../../utils/task_canceller";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scheduleRequestPromise = exports.scheduleRequestWithCdns = void 0;
+const errors_1 = require("../../../errors");
+const log_1 = require("../../../log");
+const cancellable_sleep_1 = require("../../../utils/cancellable_sleep");
+const get_fuzzed_delay_1 = require("../../../utils/get_fuzzed_delay");
+const monotonic_timestamp_1 = require("../../../utils/monotonic_timestamp");
+const noop_1 = require("../../../utils/noop");
+const task_canceller_1 = require("../../../utils/task_canceller");
 /**
  * Called on a loader error.
  * Returns whether the loader request should be retried.
@@ -69,8 +36,8 @@ import TaskCanceller from "../../../utils/task_canceller";
  * @returns {Boolean} - If true, the request can be retried.
  */
 function shouldRetry(error) {
-    if (error instanceof RequestError) {
-        if (error.type === NetworkErrorTypes.ERROR_HTTP_CODE) {
+    if (error instanceof errors_1.RequestError) {
+        if (error.type === errors_1.NetworkErrorTypes.ERROR_HTTP_CODE) {
             return error.status >= 500 ||
                 error.status === 404 ||
                 error.status === 415 || // some CDN seems to use that code when
@@ -78,10 +45,10 @@ function shouldRetry(error) {
                 // in advance
                 error.status === 412;
         }
-        return error.type === NetworkErrorTypes.TIMEOUT ||
-            error.type === NetworkErrorTypes.ERROR_EVENT;
+        return error.type === errors_1.NetworkErrorTypes.TIMEOUT ||
+            error.type === errors_1.NetworkErrorTypes.ERROR_EVENT;
     }
-    else if (error instanceof CustomLoaderError) {
+    else if (error instanceof errors_1.CustomLoaderError) {
         if (typeof error.canRetry === "boolean") {
             return error.canRetry;
         }
@@ -95,7 +62,7 @@ function shouldRetry(error) {
         }
         return false;
     }
-    return isKnownError(error) && error.code === "INTEGRITY_ERROR";
+    return (0, errors_1.isKnownError)(error) && error.code === "INTEGRITY_ERROR";
 }
 /**
  * Specific algorithm used to perform segment and manifest requests.
@@ -148,233 +115,214 @@ function shouldRetry(error) {
  *
  *   - The resource request(s) failed and will not be retried anymore.
  */
-export function scheduleRequestWithCdns(cdns, cdnPrioritizer, performRequest, options, cancellationSignal) {
-    return __awaiter(this, void 0, void 0, function () {
-        /**
-         * Returns what is now the most prioritary CDN to request the wanted resource.
-         *
-         * A return value of `null` indicates that the resource can be requested
-         * through another mean than by doing an HTTP request.
-         *
-         * A return value of `undefined` indicates that there's no CDN left to request
-         * the resource.
-         * @returns {Object|null|undefined}
-         */
-        function getCdnToRequest() {
-            if (cdns === null) {
-                var nullAttemptObject = missedAttempts.get(null);
-                if (nullAttemptObject !== undefined && nullAttemptObject.isBlacklisted) {
-                    return undefined;
-                }
-                return null;
+async function scheduleRequestWithCdns(cdns, cdnPrioritizer, performRequest, options, cancellationSignal) {
+    if (cancellationSignal.cancellationError !== null) {
+        return Promise.reject(cancellationSignal.cancellationError);
+    }
+    const { baseDelay, maxDelay, maxRetry, onRetry } = options;
+    if (cdns !== null && cdns.length === 0) {
+        log_1.default.warn("Fetchers: no CDN given to `scheduleRequestWithCdns`.");
+    }
+    const missedAttempts = new Map();
+    const initialCdnToRequest = getCdnToRequest();
+    if (initialCdnToRequest === undefined) {
+        throw new Error("No CDN to request");
+    }
+    return requestCdn(initialCdnToRequest);
+    /**
+     * Returns what is now the most prioritary CDN to request the wanted resource.
+     *
+     * A return value of `null` indicates that the resource can be requested
+     * through another mean than by doing an HTTP request.
+     *
+     * A return value of `undefined` indicates that there's no CDN left to request
+     * the resource.
+     * @returns {Object|null|undefined}
+     */
+    function getCdnToRequest() {
+        if (cdns === null) {
+            const nullAttemptObject = missedAttempts.get(null);
+            if (nullAttemptObject !== undefined && nullAttemptObject.isBlacklisted) {
+                return undefined;
+            }
+            return null;
+        }
+        else if (cdnPrioritizer === null) {
+            return getPrioritaryRequestableCdnFromSortedList(cdns);
+        }
+        else {
+            const prioritized = cdnPrioritizer.getCdnPreferenceForResource(cdns);
+            return getPrioritaryRequestableCdnFromSortedList(prioritized);
+        }
+    }
+    /**
+     * Perform immediately the request for the given CDN.
+     *
+     * If it fails, forbid the CDN from being used - optionally and in some
+     * conditions, only temporarily, then try the next CDN according to
+     * previously-set delays (with a potential sleep before to respect them).
+     *
+     * Reject if both the request fails and there's no CDN left to use.
+     * @param {string|null} cdn
+     * @returns {Promise}
+     */
+    async function requestCdn(cdn) {
+        try {
+            const res = await performRequest(cdn, cancellationSignal);
+            return res;
+        }
+        catch (error) {
+            if (task_canceller_1.default.isCancellationError(error)) {
+                throw error;
             }
-            else if (cdnPrioritizer === null) {
-                return getPrioritaryRequestableCdnFromSortedList(cdns);
+            if (cdn !== null && cdnPrioritizer !== null) {
+                // We failed requesting the resource on this CDN.
+                // Globally give priority to the next CDN through the CdnPrioritizer.
+                cdnPrioritizer.downgradeCdn(cdn);
+            }
+            let missedAttemptsObj = missedAttempts.get(cdn);
+            if (missedAttemptsObj === undefined) {
+                missedAttemptsObj = { errorCounter: 1,
+                    blockedUntil: undefined,
+                    isBlacklisted: false };
+                missedAttempts.set(cdn, missedAttemptsObj);
             }
             else {
-                var prioritized = cdnPrioritizer.getCdnPreferenceForResource(cdns);
-                return getPrioritaryRequestableCdnFromSortedList(prioritized);
+                missedAttemptsObj.errorCounter++;
+            }
+            if (!shouldRetry(error)) {
+                missedAttemptsObj.blockedUntil = undefined;
+                missedAttemptsObj.isBlacklisted = true;
+                return retryWithNextCdn(error);
             }
+            if (missedAttemptsObj.errorCounter > maxRetry) {
+                missedAttemptsObj.blockedUntil = undefined;
+                missedAttemptsObj.isBlacklisted = true;
+            }
+            else {
+                const errorCounter = missedAttemptsObj.errorCounter;
+                const delay = Math.min(baseDelay * Math.pow(2, errorCounter - 1), maxDelay);
+                const fuzzedDelay = (0, get_fuzzed_delay_1.default)(delay);
+                missedAttemptsObj.blockedUntil = (0, monotonic_timestamp_1.default)() + fuzzedDelay;
+            }
+            return retryWithNextCdn(error);
         }
-        /**
-         * Perform immediately the request for the given CDN.
-         *
-         * If it fails, forbid the CDN from being used - optionally and in some
-         * conditions, only temporarily, then try the next CDN according to
-         * previously-set delays (with a potential sleep before to respect them).
-         *
-         * Reject if both the request fails and there's no CDN left to use.
-         * @param {string|null} cdn
-         * @returns {Promise}
-         */
-        function requestCdn(cdn) {
-            return __awaiter(this, void 0, void 0, function () {
-                var res, error_1, missedAttemptsObj, errorCounter, delay, fuzzedDelay;
-                return __generator(this, function (_a) {
-                    switch (_a.label) {
-                        case 0:
-                            _a.trys.push([0, 2, , 3]);
-                            return [4 /*yield*/, performRequest(cdn, cancellationSignal)];
-                        case 1:
-                            res = _a.sent();
-                            return [2 /*return*/, res];
-                        case 2:
-                            error_1 = _a.sent();
-                            if (TaskCanceller.isCancellationError(error_1)) {
-                                throw error_1;
-                            }
-                            if (cdn !== null && cdnPrioritizer !== null) {
-                                // We failed requesting the resource on this CDN.
-                                // Globally give priority to the next CDN through the CdnPrioritizer.
-                                cdnPrioritizer.downgradeCdn(cdn);
-                            }
-                            missedAttemptsObj = missedAttempts.get(cdn);
-                            if (missedAttemptsObj === undefined) {
-                                missedAttemptsObj = { errorCounter: 1,
-                                    blockedUntil: undefined,
-                                    isBlacklisted: false };
-                                missedAttempts.set(cdn, missedAttemptsObj);
-                            }
-                            else {
-                                missedAttemptsObj.errorCounter++;
-                            }
-                            if (!shouldRetry(error_1)) {
-                                missedAttemptsObj.blockedUntil = undefined;
-                                missedAttemptsObj.isBlacklisted = true;
-                                return [2 /*return*/, retryWithNextCdn(error_1)];
-                            }
-                            if (missedAttemptsObj.errorCounter > maxRetry) {
-                                missedAttemptsObj.blockedUntil = undefined;
-                                missedAttemptsObj.isBlacklisted = true;
-                            }
-                            else {
-                                errorCounter = missedAttemptsObj.errorCounter;
-                                delay = Math.min(baseDelay * Math.pow(2, errorCounter - 1), maxDelay);
-                                fuzzedDelay = getFuzzedDelay(delay);
-                                missedAttemptsObj.blockedUntil = getTimestamp() + fuzzedDelay;
-                            }
-                            return [2 /*return*/, retryWithNextCdn(error_1)];
-                        case 3: return [2 /*return*/];
-                    }
-                });
-            });
+    }
+    /**
+     * After a request error, find the new most prioritary CDN and perform the
+     * request with it, optionally after a delay.
+     *
+     * If there's no CDN left to test, reject the original request error.
+     * @param {*} prevRequestError
+     * @returns {Promise}
+     */
+    async function retryWithNextCdn(prevRequestError) {
+        const nextCdn = getCdnToRequest();
+        if (cancellationSignal.isCancelled()) {
+            throw cancellationSignal.cancellationError;
         }
-        /**
-         * After a request error, find the new most prioritary CDN and perform the
-         * request with it, optionally after a delay.
-         *
-         * If there's no CDN left to test, reject the original request error.
-         * @param {*} prevRequestError
-         * @returns {Promise}
-         */
-        function retryWithNextCdn(prevRequestError) {
-            return __awaiter(this, void 0, void 0, function () {
-                var nextCdn;
-                return __generator(this, function (_a) {
-                    nextCdn = getCdnToRequest();
-                    if (cancellationSignal.isCancelled()) {
-                        throw cancellationSignal.cancellationError;
-                    }
-                    if (nextCdn === undefined) {
-                        throw prevRequestError;
-                    }
-                    onRetry(prevRequestError);
-                    if (cancellationSignal.isCancelled()) {
-                        throw cancellationSignal.cancellationError;
-                    }
-                    return [2 /*return*/, waitPotentialBackoffAndRequest(nextCdn, prevRequestError)];
-                });
-            });
+        if (nextCdn === undefined) {
+            throw prevRequestError;
         }
-        /**
-         * Request the corresponding CDN after the optional backoff needed before
-         * requesting it.
-         *
-         * If a new CDN become prioritary in the meantime, request it instead, again
-         * awaiting its optional backoff delay if it exists.
-         * @param {string|null} nextWantedCdn
-         * @param {*} prevRequestError
-         * @returns {Promise}
-         */
-        function waitPotentialBackoffAndRequest(nextWantedCdn, prevRequestError) {
-            var nextCdnAttemptObj = missedAttempts.get(nextWantedCdn);
-            if (nextCdnAttemptObj === undefined ||
-                nextCdnAttemptObj.blockedUntil === undefined) {
-                return requestCdn(nextWantedCdn);
-            }
-            var now = getTimestamp();
-            var blockedFor = nextCdnAttemptObj.blockedUntil - now;
-            if (blockedFor <= 0) {
-                return requestCdn(nextWantedCdn);
-            }
-            var canceller = new TaskCanceller();
-            var unlinkCanceller = canceller.linkToSignal(cancellationSignal);
-            return new Promise(function (res, rej) {
-                /* eslint-disable-next-line @typescript-eslint/no-misused-promises */
-                cdnPrioritizer === null || cdnPrioritizer === void 0 ? void 0 : cdnPrioritizer.addEventListener("priorityChange", function () {
-                    var updatedPrioritaryCdn = getCdnToRequest();
-                    if (cancellationSignal.isCancelled()) {
-                        throw cancellationSignal.cancellationError;
-                    }
-                    if (updatedPrioritaryCdn === undefined) {
-                        return cleanAndReject(prevRequestError);
-                    }
-                    if (updatedPrioritaryCdn !== nextWantedCdn) {
-                        canceller.cancel();
-                        waitPotentialBackoffAndRequest(updatedPrioritaryCdn, prevRequestError)
-                            .then(cleanAndResolve, cleanAndReject);
-                    }
-                }, canceller.signal);
-                cancellableSleep(blockedFor, canceller.signal)
-                    .then(function () { return requestCdn(nextWantedCdn)
-                    .then(cleanAndResolve, cleanAndReject); }, noop);
-                function cleanAndResolve(response) {
-                    unlinkCanceller();
-                    res(response);
-                }
-                function cleanAndReject(err) {
-                    unlinkCanceller();
-                    rej(err);
-                }
-            });
+        onRetry(prevRequestError);
+        if (cancellationSignal.isCancelled()) {
+            throw cancellationSignal.cancellationError;
         }
-        /**
-         * Takes in input the list of CDN that can be used to request the resource, in
-         * a general preference order.
-         *
-         * Returns the actual most prioritary Cdn to request, based on the current
-         * attempts already done for that resource.
-         *
-         * Returns `undefined` if there's no Cdn left to request the resource.
-         * @param {Array.<Object>}
-         * @returns {Object|undefined}
-         */
-        function getPrioritaryRequestableCdnFromSortedList(sortedCdns) {
-            var _a;
-            if (missedAttempts.size === 0) {
-                return sortedCdns[0];
-            }
-            var now = getTimestamp();
-            return (_a = sortedCdns
-                .filter(function (c) { var _a; return ((_a = missedAttempts.get(c)) === null || _a === void 0 ? void 0 : _a.isBlacklisted) !== true; })
-                .reduce(function (acc, x) {
-                var _a;
-                var blockedUntil = (_a = missedAttempts.get(x)) === null || _a === void 0 ? void 0 : _a.blockedUntil;
-                if (blockedUntil !== undefined && blockedUntil <= now) {
-                    blockedUntil = undefined;
+        return waitPotentialBackoffAndRequest(nextCdn, prevRequestError);
+    }
+    /**
+     * Request the corresponding CDN after the optional backoff needed before
+     * requesting it.
+     *
+     * If a new CDN become prioritary in the meantime, request it instead, again
+     * awaiting its optional backoff delay if it exists.
+     * @param {string|null} nextWantedCdn
+     * @param {*} prevRequestError
+     * @returns {Promise}
+     */
+    function waitPotentialBackoffAndRequest(nextWantedCdn, prevRequestError) {
+        const nextCdnAttemptObj = missedAttempts.get(nextWantedCdn);
+        if (nextCdnAttemptObj === undefined ||
+            nextCdnAttemptObj.blockedUntil === undefined) {
+            return requestCdn(nextWantedCdn);
+        }
+        const now = (0, monotonic_timestamp_1.default)();
+        const blockedFor = nextCdnAttemptObj.blockedUntil - now;
+        if (blockedFor <= 0) {
+            return requestCdn(nextWantedCdn);
+        }
+        const canceller = new task_canceller_1.default();
+        const unlinkCanceller = canceller.linkToSignal(cancellationSignal);
+        return new Promise((res, rej) => {
+            /* eslint-disable-next-line @typescript-eslint/no-misused-promises */
+            cdnPrioritizer === null || cdnPrioritizer === void 0 ? void 0 : cdnPrioritizer.addEventListener("priorityChange", () => {
+                const updatedPrioritaryCdn = getCdnToRequest();
+                if (cancellationSignal.isCancelled()) {
+                    throw cancellationSignal.cancellationError;
                 }
-                if (acc === undefined) {
-                    return [x, blockedUntil];
+                if (updatedPrioritaryCdn === undefined) {
+                    return cleanAndReject(prevRequestError);
                 }
-                if (blockedUntil === undefined) {
-                    if (acc[1] === undefined) {
-                        return acc;
-                    }
-                    return [x, undefined];
+                if (updatedPrioritaryCdn !== nextWantedCdn) {
+                    canceller.cancel();
+                    waitPotentialBackoffAndRequest(updatedPrioritaryCdn, prevRequestError)
+                        .then(cleanAndResolve, cleanAndReject);
                 }
-                return acc[1] === undefined ? acc :
-                    blockedUntil < acc[1] ? [x, blockedUntil] :
-                        acc;
-            }, undefined)) === null || _a === void 0 ? void 0 : _a[0];
+            }, canceller.signal);
+            (0, cancellable_sleep_1.default)(blockedFor, canceller.signal)
+                .then(() => requestCdn(nextWantedCdn)
+                .then(cleanAndResolve, cleanAndReject), noop_1.default);
+            function cleanAndResolve(response) {
+                unlinkCanceller();
+                res(response);
+            }
+            function cleanAndReject(err) {
+                unlinkCanceller();
+                rej(err);
+            }
+        });
+    }
+    /**
+     * Takes in input the list of CDN that can be used to request the resource, in
+     * a general preference order.
+     *
+     * Returns the actual most prioritary Cdn to request, based on the current
+     * attempts already done for that resource.
+     *
+     * Returns `undefined` if there's no Cdn left to request the resource.
+     * @param {Array.<Object>}
+     * @returns {Object|undefined}
+     */
+    function getPrioritaryRequestableCdnFromSortedList(sortedCdns) {
+        var _a;
+        if (missedAttempts.size === 0) {
+            return sortedCdns[0];
         }
-        var baseDelay, maxDelay, maxRetry, onRetry, missedAttempts, initialCdnToRequest;
-        return __generator(this, function (_a) {
-            if (cancellationSignal.cancellationError !== null) {
-                return [2 /*return*/, Promise.reject(cancellationSignal.cancellationError)];
+        const now = (0, monotonic_timestamp_1.default)();
+        return (_a = sortedCdns
+            .filter(c => { var _a; return ((_a = missedAttempts.get(c)) === null || _a === void 0 ? void 0 : _a.isBlacklisted) !== true; })
+            .reduce((acc, x) => {
+            var _a;
+            let blockedUntil = (_a = missedAttempts.get(x)) === null || _a === void 0 ? void 0 : _a.blockedUntil;
+            if (blockedUntil !== undefined && blockedUntil <= now) {
+                blockedUntil = undefined;
             }
-            baseDelay = options.baseDelay, maxDelay = options.maxDelay, maxRetry = options.maxRetry, onRetry = options.onRetry;
-            if (cdns !== null && cdns.length === 0) {
-                log.warn("Fetchers: no CDN given to `scheduleRequestWithCdns`.");
+            if (acc === undefined) {
+                return [x, blockedUntil];
             }
-            missedAttempts = new Map();
-            initialCdnToRequest = getCdnToRequest();
-            if (initialCdnToRequest === undefined) {
-                throw new Error("No CDN to request");
+            if (blockedUntil === undefined) {
+                if (acc[1] === undefined) {
+                    return acc;
+                }
+                return [x, undefined];
             }
-            return [2 /*return*/, requestCdn(initialCdnToRequest)];
-        });
-    });
+            return acc[1] === undefined ? acc :
+                blockedUntil < acc[1] ? [x, blockedUntil] :
+                    acc;
+        }, undefined)) === null || _a === void 0 ? void 0 : _a[0];
+    }
 }
+exports.scheduleRequestWithCdns = scheduleRequestWithCdns;
 /**
  * Lightweight version of the request algorithm, this time with only a simple
  * Promise given.
@@ -382,7 +330,8 @@ export function scheduleRequestWithCdns(cdns, cdnPrioritizer, performRequest, op
  * @param {Object} options
  * @returns {Promise}
  */
-export function scheduleRequestPromise(performRequest, options, cancellationSignal) {
+function scheduleRequestPromise(performRequest, options, cancellationSignal) {
     // same than for a single unknown CDN
     return scheduleRequestWithCdns(null, null, performRequest, options, cancellationSignal);
 }
+exports.scheduleRequestPromise = scheduleRequestPromise;