rx-player 3.29.0-dev.2022091600 → 3.29.0-dev.2022103100

package/dist/_esm5.processed/core/fetchers/segment/segment_fetcher.d.ts

@@ -19,6 +19,7 @@ import { ISegmentParserParsedInitChunk, ISegmentParserParsedMediaChunk, ISegment
 import { CancellationSignal } from "../../../utils/task_canceller";
 import { IMetricsCallbackPayload, IRequestBeginCallbackPayload, IRequestEndCallbackPayload, IRequestProgressCallbackPayload } from "../../adaptive";
 import { IBufferType } from "../../segment_buffers";
+import CdnPrioritizer from "../cdn_prioritizer";
 /**
  * Create an `ISegmentFetcher` object which will allow to easily fetch and parse
  * segments.
@@ -31,7 +32,7 @@ import { IBufferType } from "../../segment_buffers";
  * @param {Object} options
  * @returns {Function}
  */
-export default function createSegmentFetcher<TLoadedFormat, TSegmentDataType>(bufferType: IBufferType, pipeline: ISegmentPipeline<TLoadedFormat, TSegmentDataType>, lifecycleCallbacks: ISegmentFetcherLifecycleCallbacks, options: ISegmentFetcherOptions): ISegmentFetcher<TSegmentDataType>;
+export default function createSegmentFetcher<TLoadedFormat, TSegmentDataType>(bufferType: IBufferType, pipeline: ISegmentPipeline<TLoadedFormat, TSegmentDataType>, cdnPrioritizer: CdnPrioritizer | null, lifecycleCallbacks: ISegmentFetcherLifecycleCallbacks, options: ISegmentFetcherOptions): ISegmentFetcher<TSegmentDataType>;
 /**
  * Defines the `ISegmentFetcher` function which allows to load a single segment.
  *

package/dist/_esm5.processed/core/fetchers/segment/segment_fetcher.js

@@ -60,7 +60,7 @@ import isNullOrUndefined from "../../../utils/is_null_or_undefined";
 import objectAssign from "../../../utils/object_assign";
 import { CancellationError, } from "../../../utils/task_canceller";
 import errorSelector from "../utils/error_selector";
-import { tryURLsWithBackoff } from "../utils/try_urls_with_backoff";
+import { scheduleRequestWithCdns } from "../utils/schedule_request";
 /** Allows to generate a unique identifies for each request. */
 var generateRequestID = idGenerator();
 /**
@@ -75,7 +75,7 @@ var generateRequestID = idGenerator();
  * @param {Object} options
  * @returns {Function}
  */
-export default function createSegmentFetcher(bufferType, pipeline, lifecycleCallbacks, options) {
+export default function createSegmentFetcher(bufferType, pipeline, cdnPrioritizer, lifecycleCallbacks, options) {
     var requestOptions = {
         timeout: options.requestTimeout < 0 ? undefined :
             options.requestTimeout,
@@ -97,15 +97,15 @@ export default function createSegmentFetcher(bufferType, pipeline, lifecycleCall
      * @returns {Promise}
      */
     return function fetchSegment(content, fetcherCallbacks, cancellationSignal) {
-        var _a, _b, _c;
+        var _a, _b;
         return __awaiter(this, void 0, void 0, function () {
             /**
              * Call a segment loader for the given URL with the right arguments.
-             * @param {string|null} url
+             * @param {Object|null} cdnMetadata
              * @returns {Promise}
              */
-            function callLoaderWithUrl(url) {
-                return loadSegment(url, content, requestOptions, cancellationSignal, loaderCallbacks);
+            function callLoaderWithUrl(cdnMetadata) {
+                return loadSegment(cdnMetadata, content, requestOptions, cancellationSignal, loaderCallbacks);
             }
             /**
              * Generate function allowing to parse a loaded segment.
@@ -168,11 +168,10 @@ export default function createSegmentFetcher(bufferType, pipeline, lifecycleCall
                     });
                 }
             }
-            var segment, segmentIdString, requestId, requestInfo, parsedChunks, segmentDurationAcc, metricsSent, loaderCallbacks, cached, res, loadedData, err_1;
-            return __generator(this, function (_d) {
-                switch (_d.label) {
+            var segmentIdString, requestId, requestInfo, parsedChunks, segmentDurationAcc, metricsSent, loaderCallbacks, cached, res, loadedData, err_1;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
                     case 0:
-                        segment = content.segment;
                         segmentIdString = getLoggableSegmentId(content);
                         requestId = generateRequestID();
                         parsedChunks = [];
@@ -226,12 +225,12 @@ export default function createSegmentFetcher(bufferType, pipeline, lifecycleCall
                             requestInfo = null;
                             (_a = lifecycleCallbacks.onRequestEnd) === null || _a === void 0 ? void 0 : _a.call(lifecycleCallbacks, { id: requestId });
                         });
-                        _d.label = 1;
+                        _c.label = 1;
                     case 1:
-                        _d.trys.push([1, 3, , 4]);
-                        return [4 /*yield*/, tryURLsWithBackoff((_b = segment.mediaURLs) !== null && _b !== void 0 ? _b : [null], callLoaderWithUrl, objectAssign({ onRetry: onRetry }, options), cancellationSignal)];
+                        _c.trys.push([1, 3, , 4]);
+                        return [4 /*yield*/, scheduleRequestWithCdns(content.representation.cdnMetadata, cdnPrioritizer, callLoaderWithUrl, objectAssign({ onRetry: onRetry }, options), cancellationSignal)];
                     case 2:
-                        res = _d.sent();
+                        res = _c.sent();
                         if (res.resultType === "segment-loaded") {
                             loadedData = res.resultData.responseData;
                             if (cache !== undefined) {
@@ -255,11 +254,11 @@ export default function createSegmentFetcher(bufferType, pipeline, lifecycleCall
                             // The current task could have been canceled as a result of one
                             // of the previous callbacks call. In that case, we don't want to send
                             // a "requestEnd" again as it has already been sent on cancellation.
-                            (_c = lifecycleCallbacks.onRequestEnd) === null || _c === void 0 ? void 0 : _c.call(lifecycleCallbacks, { id: requestId });
+                            (_b = lifecycleCallbacks.onRequestEnd) === null || _b === void 0 ? void 0 : _b.call(lifecycleCallbacks, { id: requestId });
                         }
                         return [3 /*break*/, 4];
                     case 3:
-                        err_1 = _d.sent();
+                        err_1 = _c.sent();
                         requestInfo = null;
                         if (err_1 instanceof CancellationError) {
                             log.debug("SF: Segment request aborted", segmentIdString);

package/dist/_esm5.processed/core/fetchers/segment/segment_fetcher_creator.d.ts

@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 import { ITransportPipelines } from "../../../transports";
+import { CancellationSignal } from "../../../utils/task_canceller";
 import { IBufferType } from "../../segment_buffers";
 import { IPrioritizedSegmentFetcher } from "./prioritized_segment_fetcher";
 import { ISegmentFetcherLifecycleCallbacks } from "./segment_fetcher";
@@ -67,10 +68,11 @@ export default class SegmentFetcherCreator {
      * segment retries (number of retries maximum, default delay and so on).
      */
     private readonly _backoffOptions;
+    private readonly _cdnPrioritizer;
     /**
      * @param {Object} transport
      */
-    constructor(transport: ITransportPipelines, options: ISegmentFetcherCreatorBackoffOptions);
+    constructor(transport: ITransportPipelines, options: ISegmentFetcherCreatorBackoffOptions, cancelSignal: CancellationSignal);
     /**
      * Create a segment fetcher, allowing to easily perform segment requests.
      * @param {string} bufferType - The type of buffer concerned (e.g. "audio",

package/dist/_esm5.processed/core/fetchers/segment/segment_fetcher_creator.js

@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 import config from "../../../config";
+import CdnPrioritizer from "../cdn_prioritizer";
 import applyPrioritizerToSegmentFetcher from "./prioritized_segment_fetcher";
 import createSegmentFetcher, { getSegmentFetcherOptions, } from "./segment_fetcher";
 import TaskPrioritizer from "./task_prioritizer";
@@ -51,13 +52,15 @@ var SegmentFetcherCreator = /** @class */ (function () {
     /**
      * @param {Object} transport
      */
-    function SegmentFetcherCreator(transport, options) {
+    function SegmentFetcherCreator(transport, options, cancelSignal) {
+        var cdnPrioritizer = new CdnPrioritizer(cancelSignal);
         var _a = config.getCurrent(), MIN_CANCELABLE_PRIORITY = _a.MIN_CANCELABLE_PRIORITY, MAX_HIGH_PRIORITY_LEVEL = _a.MAX_HIGH_PRIORITY_LEVEL;
         this._transport = transport;
         this._prioritizer = new TaskPrioritizer({
             prioritySteps: { high: MAX_HIGH_PRIORITY_LEVEL,
                 low: MIN_CANCELABLE_PRIORITY },
         });
+        this._cdnPrioritizer = cdnPrioritizer;
         this._backoffOptions = options;
     }
     /**
@@ -71,7 +74,7 @@ var SegmentFetcherCreator = /** @class */ (function () {
         var backoffOptions = getSegmentFetcherOptions(bufferType, this._backoffOptions);
         var pipelines = this._transport[bufferType];
         // Types are very complicated here as they are per-type of buffer.
-        var segmentFetcher = createSegmentFetcher(bufferType, pipelines, callbacks, backoffOptions);
+        var segmentFetcher = createSegmentFetcher(bufferType, pipelines, this._cdnPrioritizer, callbacks, backoffOptions);
         return applyPrioritizerToSegmentFetcher(this._prioritizer, segmentFetcher);
     };
     return SegmentFetcherCreator;

package/dist/_esm5.processed/core/fetchers/utils/schedule_request.d.ts

@@ -0,0 +1,103 @@
+/**
+ * Copyright 2015 CANAL+ Group
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { ICdnMetadata } from "../../../parsers/manifest";
+import { CancellationSignal } from "../../../utils/task_canceller";
+import CdnPrioritizer from "../cdn_prioritizer";
+/** Settings to give to the backoff functions to configure their behavior. */
+export interface IBackoffSettings {
+    /**
+     * Initial delay to wait if a request fails before making a new request, in
+     * milliseconds.
+     */
+    baseDelay: number;
+    /**
+     * Maximum delay to wait if a request fails before making a new request, in
+     * milliseconds.
+     */
+    maxDelay: number;
+    /**
+     * Maximum number of retries to perform on "regular" errors (e.g. due to HTTP
+     * status, integrity errors, timeouts...).
+     */
+    maxRetryRegular: number;
+    /**
+     * Maximum number of retries to perform when it appears that the user is
+     * currently offline.
+     */
+    maxRetryOffline: number;
+    /** Callback called when a request is retried. */
+    onRetry: (err: unknown) => void;
+}
+/**
+ * Specific algorithm used to perform segment and manifest requests.
+ *
+ * Here how it works:
+ *
+ *   1. You give it one or multiple of the CDN available for the resource you
+ *      want to request (from the most important one to the least important),
+ *      a callback doing the request with the chosen CDN in argument, and some
+ *      options.
+ *
+ *   2. it tries to call the request callback with the most prioritized CDN
+ *      first:
+ *        - if it works as expected, it resolves the returned Promise with that
+ *          request's response.
+ *        - if it fails, it calls ther `onRetry` callback given with the
+ *          corresponding error, un-prioritize that CDN and try with the new
+ *          most prioritized CDN.
+ *
+ *      Each CDN might be retried multiple times, depending on the nature of the
+ *      error and the Configuration given.
+ *
+ *      Multiple retries of the same CDN are done after a delay to avoid
+ *      overwhelming it, this is what we call a "backoff". That delay raises
+ *      exponentially as multiple consecutive errors are encountered on this
+ *      CDN.
+ *
+ * @param {Array.<string>|null} cdns - The different CDN on which the
+ * wanted resource is available. `scheduleRequestWithCdns` will call the
+ * `performRequest` callback with the right element from that array if different
+ * from `null`.
+ *
+ * Can be set to `null` when that resource is not reachable through a CDN, in
+ * which case the `performRequest` callback may be called with `null`.
+ * @param {Object|null} cdnPrioritizer - Interface allowing to give the priority
+ * between multiple CDNs.
+ * @param {Function} performRequest - Callback implementing the request in
+ * itself. Resolving when the resource request succeed and rejecting with the
+ * corresponding error when the request failed.
+ * @param {Object} options - Configuration allowing to tweak the number on which
+ * the algorithm behind `scheduleRequestWithCdns` bases itself.
+ * @param {Object} cancellationSignal - CancellationSignal allowing to cancel
+ * the logic of `scheduleRequestWithCdns`.
+ * To trigger if the resource is not needed anymore.
+ * @returns {Promise} - Promise resolving, with the corresponding
+ * `performRequest`'s data, when the resource request succeed and rejecting in
+ * the following scenarios:
+ *   - `scheduleRequestWithCdns` has been cancelled due to `cancellationSignal`
+ *     being triggered. In that case a `CancellationError` is thrown.
+ *
+ *   - The resource request(s) failed and will not be retried anymore.
+ */
+export declare function scheduleRequestWithCdns<T>(cdns: ICdnMetadata[] | null, cdnPrioritizer: CdnPrioritizer | null, performRequest: (cdn: ICdnMetadata | null, cancellationSignal: CancellationSignal) => Promise<T>, options: IBackoffSettings, cancellationSignal: CancellationSignal): Promise<T>;
+/**
+ * Lightweight version of the request algorithm, this time with only a simple
+ * Promise given.
+ * @param {Function} performRequest
+ * @param {Object} options
+ * @returns {Promise}
+ */
+export declare function scheduleRequestPromise<T>(performRequest: () => Promise<T>, options: IBackoffSettings, cancellationSignal: CancellationSignal): Promise<T>;