rx-player 3.25.2 → 3.26.3-dev.2022021400

package/src/core/fetchers/manifest/manifest_fetcher.ts

@@ -15,17 +15,9 @@
  */
 
 import {
-  merge as observableMerge,
   Observable,
-  of as observableOf,
-  Subject,
 } from "rxjs";
-import {
-  catchError,
-  finalize,
-  map,
-  mergeMap,
-} from "rxjs/operators";
+import config from "../../../config";
 import {
   formatError,
   ICustomError,
@@ -33,21 +25,23 @@ import {
 import log from "../../../log";
 import Manifest from "../../../manifest";
 import {
-  ILoaderDataLoadedValue,
-  IManifestLoaderArguments,
-  IManifestLoaderFunction,
-  IManifestResolverFunction,
+  IRequestedData,
   ITransportManifestPipeline,
   ITransportPipelines,
 } from "../../../transports";
-import tryCatch$ from "../../../utils/rx-try_catch";
-import createRequestScheduler from "../utils/create_request_scheduler";
+import assert from "../../../utils/assert";
+import PPromise from "../../../utils/promise";
+import TaskCanceller from "../../../utils/task_canceller";
 import errorSelector from "../utils/error_selector";
 import {
-  IBackoffOptions,
-  tryRequestObservableWithBackoff,
+  IBackoffSettings,
+  tryRequestPromiseWithBackoff,
 } from "../utils/try_urls_with_backoff";
-import getManifestBackoffOptions from "./get_manifest_backoff_options";
+
+const { DEFAULT_MAX_MANIFEST_REQUEST_RETRY,
+        DEFAULT_MAX_REQUESTS_RETRY_ON_OFFLINE,
+        INITIAL_BACKOFF_DELAY_BASE,
+        MAX_BACKOFF_DELAY_BASE } = config;
 
 /** What will be sent once parsed. */
 export interface IManifestFetcherParsedResult {
@@ -60,11 +54,11 @@ export interface IManifestFetcherParsedResult {
    * The time (`performance.now()`) at which the request was started (at which
    * the JavaScript call was done).
    */
-  sendingTime? : number;
+  sendingTime? : number | undefined;
   /** The time (`performance.now()`) at which the request was fully received. */
-  receivedTime? : number;
+  receivedTime? : number | undefined;
   /* The time taken to parse the Manifest through the corresponding parse function. */
-  parsingTime? : number;
+  parsingTime? : number | undefined;
 }
 
 /** Emitted when a fetching or parsing minor error happened. */
@@ -92,7 +86,7 @@ export interface IManifestFetcherParserOptions {
    * If set, offset to add to `performance.now()` to obtain the current
    * server's time.
    */
-  externalClockOffset? : number;
+  externalClockOffset? : number | undefined;
   /** The previous value of the Manifest (when updating). */
   previousManifest : Manifest | null;
   /**
@@ -106,7 +100,7 @@ export interface IManifestFetcherParserOptions {
 }
 
 /** Options used by `createManifestFetcher`. */
-export interface IManifestFetcherBackoffOptions {
+export interface IManifestFetcherSettings {
   /**
    * Whether the content is played in a low-latency mode.
    * This has an impact on default backoff delays.
@@ -137,66 +131,121 @@ export interface IManifestFetcherBackoffOptions {
  * ```
  */
 export default class ManifestFetcher {
-  private _backoffOptions : IBackoffOptions;
+  private _settings : IManifestFetcherSettings;
   private _manifestUrl : string | undefined;
   private _pipelines : ITransportManifestPipeline;
 
   /**
-   * @param {string | undefined} url
-   * @param {Object} pipelines
-   * @param {Object} backoffOptions
+   * Construct a new ManifestFetcher.
+   * @param {string | undefined} url - Default Manifest url, will be used when
+   * no URL is provided to the `fetch` function.
+   * `undefined` if unknown or if a Manifest should be retrieved through other
+   * means than an HTTP request.
+   * @param {Object} pipelines - Transport pipelines used to perform the
+   * Manifest loading and parsing operations.
+   * @param {Object} settings - Configure the `ManifestFetcher`.
    */
   constructor(
     url : string | undefined,
     pipelines : ITransportPipelines,
-    backoffOptions : IManifestFetcherBackoffOptions
+    settings : IManifestFetcherSettings
   ) {
     this._manifestUrl = url;
     this._pipelines = pipelines.manifest;
-    this._backoffOptions = getManifestBackoffOptions(backoffOptions);
+    this._settings = settings;
   }
 
   /**
-   * (re-)Load the Manifest without yet parsing it.
+   * (re-)Load the Manifest.
+   * This method does not yet parse it, parsing will then be available through
+   * a callback available on the response.
    *
    * You can set an `url` on which that Manifest will be requested.
-   * If not set, the regular Manifest url - defined on the
-   * `ManifestFetcher` instanciation - will be used instead.
+   * If not set, the regular Manifest url - defined on the `ManifestFetcher`
+   * instanciation - will be used instead.
+   *
    * @param {string} [url]
    * @returns {Observable}
    */
   public fetch(url? : string) : Observable<IManifestFetcherResponse |
-                                   IManifestFetcherWarningEvent> {
-    const requestUrl = url ?? this._manifestUrl;
-
-    // TODO Remove the resolver completely in the next major version
-    const resolver : IManifestResolverFunction =
-      this._pipelines.resolver ??
-      observableOf;
-
-    const loader : IManifestLoaderFunction = this._pipelines.loader;
-
-    return tryCatch$(resolver, { url: requestUrl }).pipe(
-      catchError((error : Error) : Observable<never> => {
-        throw errorSelector(error);
-      }),
-      mergeMap((loaderArgument : IManifestLoaderArguments) => {
-        const loader$ = tryCatch$(loader, loaderArgument);
-        return tryRequestObservableWithBackoff(loader$, this._backoffOptions).pipe(
-          catchError((error : unknown) : Observable<never> => {
-            throw errorSelector(error);
-          }),
-          map((evt) => {
-            return evt.type === "retry" ?
-              ({ type: "warning" as const, value: errorSelector(evt.value) }) :
-              ({
-                type: "response" as const,
-                parse: (parserOptions : IManifestFetcherParserOptions) => {
-                  return this._parseLoadedManifest(evt.value.value, parserOptions);
-                },
-              });
-          }));
-      }));
+                                           IManifestFetcherWarningEvent>
+  {
+    return new Observable((obs) => {
+      const pipelines = this._pipelines;
+      const requestUrl = url ?? this._manifestUrl;
+
+      /** `true` if the loading pipeline is already completely executed. */
+      let hasFinishedLoading = false;
+
+      /** Allows to cancel the loading operation. */
+      const canceller = new TaskCanceller();
+
+      const backoffSettings = this._getBackoffSetting((err) => {
+        obs.next({ type: "warning", value: errorSelector(err) });
+      });
+
+      const loadingPromise = pipelines.resolveManifestUrl === undefined ?
+        callLoaderWithRetries(requestUrl) :
+        callResolverWithRetries(requestUrl).then(callLoaderWithRetries);
+
+      loadingPromise
+        .then(response => {
+          hasFinishedLoading = true;
+          obs.next({
+            type: "response",
+            parse: (parserOptions : IManifestFetcherParserOptions) => {
+              return this._parseLoadedManifest(response, parserOptions);
+            },
+          });
+          obs.complete();
+        })
+        .catch((err : unknown) => {
+          if (canceller.isUsed) {
+            // Cancellation has already been handled by RxJS
+            return;
+          }
+          hasFinishedLoading = true;
+          obs.error(errorSelector(err));
+        });
+
+      return () => {
+        if (!hasFinishedLoading) {
+          canceller.cancel();
+        }
+      };
+
+      /**
+       * Call the resolver part of the pipeline, retrying if it fails according
+       * to the current settings.
+       * Returns the Promise of the last attempt.
+       * /!\ This pipeline should have a `resolveManifestUrl` function defined.
+       * @param {string | undefined}  resolverUrl
+       * @returns {Promise}
+       */
+      function callResolverWithRetries(resolverUrl : string | undefined) {
+        const { resolveManifestUrl } = pipelines;
+        assert(resolveManifestUrl !== undefined);
+        const callResolver = () => resolveManifestUrl(resolverUrl, canceller.signal);
+        return tryRequestPromiseWithBackoff(callResolver,
+                                            backoffSettings,
+                                            canceller.signal);
+      }
+
+      /**
+       * Call the loader part of the pipeline, retrying if it fails according
+       * to the current settings.
+       * Returns the Promise of the last attempt.
+       * @param {string | undefined}  resolverUrl
+       * @returns {Promise}
+       */
+      function callLoaderWithRetries(manifestUrl : string | undefined) {
+        const { loadManifest } = pipelines;
+        const callLoader = () => loadManifest(manifestUrl, canceller.signal);
+        return tryRequestPromiseWithBackoff(callLoader,
+                                            backoffSettings,
+                                            canceller.signal);
+      }
+    });
   }
 
   /**
@@ -217,7 +266,7 @@ export default class ManifestFetcher {
                  IManifestFetcherParsedResult> {
     return this._parseLoadedManifest({ responseData: manifest,
                                        size: undefined,
-                                       duration: undefined },
+                                       requestDuration: undefined },
                                      parserOptions);
 
   }
@@ -231,59 +280,157 @@ export default class ManifestFetcher {
    * @returns {Observable}
    */
   private _parseLoadedManifest(
-    loaded : ILoaderDataLoadedValue<unknown>,
+    loaded : IRequestedData<unknown>,
     parserOptions : IManifestFetcherParserOptions
   ) : Observable<IManifestFetcherWarningEvent |
-                 IManifestFetcherParsedResult> {
-    const { sendingTime, receivedTime } = loaded;
-    const parsingTimeStart = performance.now();
-
-    // Prepare RequestScheduler
-    // TODO Remove the need of a subject
-    type IRequestSchedulerData = ILoaderDataLoadedValue<string | ArrayBuffer | Document>;
-    const schedulerWarnings$ = new Subject<ICustomError>();
-    const scheduleRequest =
-      createRequestScheduler<IRequestSchedulerData>(this._backoffOptions,
-                                                    schedulerWarnings$);
-
-    return observableMerge(
-      schedulerWarnings$
-        .pipe(map(err => ({ type: "warning" as const, value: err }))),
-      this._pipelines.parser({ response: loaded,
-                               url: this._manifestUrl,
-                               externalClockOffset: parserOptions.externalClockOffset,
-                               previousManifest: parserOptions.previousManifest,
-                               scheduleRequest,
-                               unsafeMode: parserOptions.unsafeMode,
-      }).pipe(
-        catchError((error: unknown) => {
-          throw formatError(error, {
-            defaultCode: "PIPELINE_PARSE_ERROR",
-            defaultReason: "Unknown error when parsing the Manifest",
-          });
-        }),
-        map((parsingEvt) => {
-          if (parsingEvt.type === "warning") {
-            const formatted = formatError(parsingEvt.value, {
-              defaultCode: "PIPELINE_PARSE_ERROR",
-              defaultReason: "Unknown error when parsing the Manifest",
+                 IManifestFetcherParsedResult>
+  {
+    return new Observable(obs => {
+      const parsingTimeStart = performance.now();
+      const canceller = new TaskCanceller();
+      const { sendingTime, receivedTime } = loaded;
+      const backoffSettings = this._getBackoffSetting((err) => {
+        obs.next({ type: "warning", value: errorSelector(err) });
+      });
+
+      const opts = { externalClockOffset: parserOptions.externalClockOffset,
+                     unsafeMode: parserOptions.unsafeMode,
+                     previousManifest: parserOptions.previousManifest,
+                     originalUrl: this._manifestUrl };
+      try {
+        const res = this._pipelines.parseManifest(loaded,
+                                                  opts,
+                                                  onWarnings,
+                                                  canceller.signal,
+                                                  scheduleRequest);
+        if (!isPromise(res)) {
+          emitManifestAndComplete(res.manifest);
+        } else {
+          res
+            .then(({ manifest }) => emitManifestAndComplete(manifest))
+            .catch((err) => {
+              if (canceller.isUsed) {
+                // Cancellation is already handled by RxJS
+                return;
+              }
+              emitError(err, true);
             });
-            return { type: "warning" as const,
-                     value: formatted };
+        }
+      } catch (err) {
+        if (canceller.isUsed) {
+          // Cancellation is already handled by RxJS
+          return undefined;
+        }
+        emitError(err, true);
+      }
+
+      return () => {
+        canceller.cancel();
+      };
+
+      /**
+       * Perform a request with the same retry mechanisms and error handling
+       * than for a Manifest loader.
+       * @param {Function} performRequest
+       * @returns {Function}
+       */
+      async function scheduleRequest<T>(
+        performRequest : () => Promise<T>
+      ) : Promise<T> {
+        try {
+          const data = await tryRequestPromiseWithBackoff(performRequest,
+                                                          backoffSettings,
+                                                          canceller.signal);
+          return data;
+        } catch (err) {
+          throw errorSelector(err);
+        }
+      }
+
+      /**
+       * Handle minor errors encountered by a Manifest parser.
+       * @param {Array.<Error>} warnings
+       */
+      function onWarnings(warnings : Error[]) : void {
+        for (const warning of warnings) {
+          if (canceller.isUsed) {
+            return;
           }
+          emitError(warning, false);
+        }
+      }
 
-          // 2 - send response
-          const parsingTime = performance.now() - parsingTimeStart;
-          log.info(`MF: Manifest parsed in ${parsingTime}ms`);
+      /**
+       * Emit a formatted "parsed" event through `obs`.
+       * To call once the Manifest has been parsed.
+       * @param {Object} manifest
+       */
+      function emitManifestAndComplete(manifest : Manifest) : void {
+        onWarnings(manifest.contentWarnings);
+        const parsingTime = performance.now() - parsingTimeStart;
+        log.info(`MF: Manifest parsed in ${parsingTime}ms`);
 
-          return { type: "parsed" as const,
-                   manifest: parsingEvt.value.manifest,
+        obs.next({ type: "parsed" as const,
+                   manifest,
                    sendingTime,
                    receivedTime,
-                   parsingTime };
+                   parsingTime });
+        obs.complete();
+      }
 
-        }),
-        finalize(() => { schedulerWarnings$.complete(); })
-      ));
+      /**
+       * Format the given Error and emit it through `obs`.
+       * Either through a `"warning"` event, if `isFatal` is `false`, or through
+       * a fatal Observable error, if `isFatal` is set to `true`.
+       * @param {*} err
+       * @param {boolean} isFatal
+       */
+      function emitError(err : unknown, isFatal : boolean) : void {
+        const formattedError = formatError(err, {
+          defaultCode: "PIPELINE_PARSE_ERROR",
+          defaultReason: "Unknown error when parsing the Manifest",
+        });
+        if (isFatal) {
+          obs.error(formattedError);
+        } else {
+          obs.next({ type: "warning" as const,
+                     value: formattedError });
+        }
+      }
+    });
   }
+
+  /**
+   * Construct "backoff settings" that can be used with a range of functions
+   * allowing to perform multiple request attempts
+   * @param {Function} onRetry
+   * @returns {Object}
+   */
+  private _getBackoffSetting(onRetry : (err : unknown) => void) : IBackoffSettings {
+    const { lowLatencyMode,
+            maxRetryRegular : ogRegular,
+            maxRetryOffline : ogOffline } = this._settings;
+    const baseDelay = lowLatencyMode ? INITIAL_BACKOFF_DELAY_BASE.LOW_LATENCY :
+                                       INITIAL_BACKOFF_DELAY_BASE.REGULAR;
+    const maxDelay = lowLatencyMode ? MAX_BACKOFF_DELAY_BASE.LOW_LATENCY :
+                                      MAX_BACKOFF_DELAY_BASE.REGULAR;
+    const maxRetryRegular = ogRegular ?? DEFAULT_MAX_MANIFEST_REQUEST_RETRY;
+    const maxRetryOffline = ogOffline ?? DEFAULT_MAX_REQUESTS_RETRY_ON_OFFLINE;
+    return { onRetry,
+             baseDelay,
+             maxDelay,
+             maxRetryRegular,
+             maxRetryOffline };
+  }
+}
+
+/**
+ * Returns `true` when the returned value seems to be a Promise instance, as
+ * created by the RxPlayer.
+ * @param {*} val
+ * @returns {boolean}
+ */
+function isPromise<T>(val : T | Promise<T>) : val is Promise<T> {
+  return val instanceof PPromise ||
+         val instanceof Promise;
 }

package/src/core/fetchers/segment/__tests__/prioritizer.test.ts

@@ -16,24 +16,23 @@
 
 import {
   defer,
+  mapTo,
   merge,
   NEVER,
   of,
+  startWith,
   timer,
 } from "rxjs";
-import {
-  mapTo,
-  startWith,
-} from "rxjs/operators";
 import Prioritizer, {
   ITaskEvent,
 } from "../prioritizer";
 
 /* eslint-disable @typescript-eslint/no-floating-promises */
 /* eslint-disable @typescript-eslint/strict-boolean-expressions */
+/* eslint-disable @typescript-eslint/no-unsafe-argument */
 /* eslint-disable no-restricted-properties */
 
-function assert(condition: any, msg?: string): asserts condition {
+function assert(condition: boolean, msg?: string): asserts condition {
   if (!condition) {
     throw new Error(msg ?? "The asserted condition turned out to be false.");
   }

package/src/core/fetchers/segment/index.ts

@@ -22,7 +22,7 @@ import {
   ISegmentFetcherChunkCompleteEvent,
   ISegmentFetcherChunkEvent,
   ISegmentFetcherEvent,
-  ISegmentFetcherWarning,
+  ISegmentFetcherRetry,
 } from "./segment_fetcher";
 import SegmentFetcherCreator, {
   ISegmentFetcherCreatorBackoffOptions,
@@ -35,6 +35,6 @@ export {
   ISegmentFetcherChunkCompleteEvent,
   ISegmentFetcherChunkEvent,
   ISegmentFetcherEvent,
-  ISegmentFetcherWarning,
+  ISegmentFetcherRetry,
   ISegmentFetcherCreatorBackoffOptions,
 };

package/src/core/fetchers/segment/prioritized_segment_fetcher.ts

@@ -14,50 +14,27 @@
  * limitations under the License.
  */
 
-import { Observable } from "rxjs";
-import { map } from "rxjs/operators";
+import {
+  map,
+  Observable,
+} from "rxjs";
 import log from "../../../log";
-import { ISegmentLoaderContent } from "./create_segment_loader";
-import ObservablePrioritizer, { ITaskEvent } from "./prioritizer";
+import ObservablePrioritizer, {
+  IEndedTaskEvent,
+  IInterruptedTaskEvent,
+  ITaskEvent,
+} from "./prioritizer";
 import {
   ISegmentFetcher,
-  ISegmentFetcherEvent,
+  ISegmentFetcherChunkCompleteEvent,
+  ISegmentFetcherChunkEvent,
+  ISegmentFetcherRetry,
+  ISegmentLoaderContent,
 } from "./segment_fetcher";
 
-/**
- * Event sent when a segment request has been temporarly interrupted due to
- * another request with a high priority.
- * The request for that segment will restart (from scratch) when requests with
- * more priority are finished.
- */
-export interface ISegmentFetcherInterruptedEvent { type : "interrupted" }
-
-/**
- * Event sent when a segment request just ended.
- * You can use this event to schedule another task you wanted to perform at best
- * immediately after that one (its priority will be checked).
- */
-export interface IEndedTaskEvent { type : "ended" }
-
-/** Event sent by a `IPrioritizedSegmentFetcher`. */
-export type IPrioritizedSegmentFetcherEvent<T> = ISegmentFetcherEvent<T> |
-                                                 ISegmentFetcherInterruptedEvent |
-                                                 IEndedTaskEvent;
-
-/** Oject returned by `applyPrioritizerToSegmentFetcher`. */
-export interface IPrioritizedSegmentFetcher<T> {
-  /** Create a new request for a segment with a given priority. */
-  createRequest : (content : ISegmentLoaderContent,
-                   priority? : number) => Observable<IPrioritizedSegmentFetcherEvent<T>>;
-
-  /** Update priority of a request created through `createRequest`. */
-  updatePriority : (observable : Observable<IPrioritizedSegmentFetcherEvent<T>>,
-                    priority : number) => void;
-}
-
 /**
  * This function basically put in relation:
- *   - a SegmentFetcher, which will be used to perform the segment request
+ *   - an `ISegmentFetcher`, which will be used to perform the segment requests
  *   - a prioritizer, which will handle the priority of a segment request
  *
  * and returns functions to fetch segments with a given priority.
@@ -65,18 +42,16 @@ export interface IPrioritizedSegmentFetcher<T> {
  * @param {Object} fetcher
  * @returns {Object}
  */
-export default function applyPrioritizerToSegmentFetcher<T>(
-  prioritizer : ObservablePrioritizer<IPrioritizedSegmentFetcherEvent<T>>,
-  fetcher : ISegmentFetcher<T>
-) : IPrioritizedSegmentFetcher<T> {
-  /**
-   * The Observables returned by `createRequest` are not exactly the same than
-   * the one created by the `ObservablePrioritizer`. Because we still have to
-   * keep a handle on that value.
-   */
-  const taskHandlers =
-    new WeakMap<Observable<IPrioritizedSegmentFetcherEvent<T>>,
-                           Observable<ITaskEvent<IPrioritizedSegmentFetcherEvent<T>>>>();
+export default function applyPrioritizerToSegmentFetcher<TSegmentDataType>(
+  prioritizer : ObservablePrioritizer<IPrioritizedSegmentFetcherEvent<TSegmentDataType>>,
+  fetcher : ISegmentFetcher<TSegmentDataType>
+) : IPrioritizedSegmentFetcher<TSegmentDataType> {
+  /** Map returned task to the task as returned by the `ObservablePrioritizer`. */
+  const taskHandlers = new WeakMap<
+    Observable<IPrioritizedSegmentFetcherEvent<TSegmentDataType>>,
+    Observable<ITaskEvent<IPrioritizedSegmentFetcherEvent<TSegmentDataType>>>
+  >();
+
   return {
     /**
      * Create a Segment request with a given priority.
@@ -88,7 +63,7 @@ export default function applyPrioritizerToSegmentFetcher<T>(
     createRequest(
       content : ISegmentLoaderContent,
       priority : number = 0
-    ) : Observable<IPrioritizedSegmentFetcherEvent<T>> {
+    ) : Observable<IPrioritizedSegmentFetcherEvent<TSegmentDataType>> {
       const task = prioritizer.create(fetcher(content), priority);
       const flattenTask = task.pipe(
         map((evt) => {
@@ -107,7 +82,7 @@ export default function applyPrioritizerToSegmentFetcher<T>(
      * @param {Number} priority - The new priority value.
      */
     updatePriority(
-      observable : Observable<IPrioritizedSegmentFetcherEvent<T>>,
+      observable : Observable<IPrioritizedSegmentFetcherEvent<TSegmentDataType>>,
       priority : number
     ) : void {
       const correspondingTask = taskHandlers.get(observable);
@@ -119,3 +94,25 @@ export default function applyPrioritizerToSegmentFetcher<T>(
     },
   };
 }
+
+/** Oject returned by `applyPrioritizerToSegmentFetcher`. */
+export interface IPrioritizedSegmentFetcher<TSegmentDataType> {
+  /** Create a new request for a segment with a given priority. */
+  createRequest : (content : ISegmentLoaderContent,
+                   priority? : number) =>
+    Observable<IPrioritizedSegmentFetcherEvent<TSegmentDataType>>;
+
+  /** Update priority of a request created through `createRequest`. */
+  updatePriority : (
+    observable : Observable<IPrioritizedSegmentFetcherEvent<TSegmentDataType>>,
+    priority : number
+  ) => void;
+}
+
+/** Event sent by a `IPrioritizedSegmentFetcher`. */
+export type IPrioritizedSegmentFetcherEvent<TSegmentDataType> =
+  ISegmentFetcherChunkEvent<TSegmentDataType> |
+  ISegmentFetcherChunkCompleteEvent |
+  ISegmentFetcherRetry |
+  IInterruptedTaskEvent |
+  IEndedTaskEvent;