Source: lib/net/http_fetch_plugin.js

  1. /*! @license
  2.  * Shaka Player
  3.  * Copyright 2016 Google LLC
  4.  * SPDX-License-Identifier: Apache-2.0
  5.  */
  7. goog.provide('shaka.net.HttpFetchPlugin');
  9. goog.require('goog.asserts');
  10. goog.require('shaka.log');
  11. goog.require('shaka.net.HttpPluginUtils');
  12. goog.require('shaka.net.NetworkingEngine');
  13. goog.require('shaka.util.AbortableOperation');
  14. goog.require('shaka.util.Error');
  15. goog.require('shaka.util.MapUtils');
  16. goog.require('shaka.util.Timer');
  19. /**
  20.  * @summary A networking plugin to handle http and https URIs via the Fetch API.
  21.  * @export
  22.  */
  23. shaka.net.HttpFetchPlugin = class {
  24.   /**
  25.    * @param {string} uri
  26.    * @param {shaka.extern.Request} request
  27.    * @param {shaka.net.NetworkingEngine.RequestType} requestType
  28.    * @param {shaka.extern.ProgressUpdated} progressUpdated Called when a
  29.    *   progress event happened.
  30.    * @param {shaka.extern.HeadersReceived} headersReceived Called when the
  31.    *   headers for the download are received, but before the body is.
  32.    * @return {!shaka.extern.IAbortableOperation.<shaka.extern.Response>}
  33.    * @export
  34.    */
  35.   static parse(uri, request, requestType, progressUpdated, headersReceived) {
  36.     const headers = new shaka.net.HttpFetchPlugin.Headers_();
  37.     shaka.util.MapUtils.asMap(request.headers).forEach((value, key) => {
  38.       headers.append(key, value);
  39.     });
  41.     const controller = new shaka.net.HttpFetchPlugin.AbortController_();
  43.     /** @type {!RequestInit} */
  44.     const init = {
  45.       // Edge does not treat null as undefined for body; https://bit.ly/2luyE6x
  46.       body: request.body || undefined,
  47.       headers: headers,
  48.       method: request.method,
  49.       signal: controller.signal,
  50.       credentials: request.allowCrossSiteCredentials ? 'include' : undefined,
  51.     };
  53.     /** @type {shaka.net.HttpFetchPlugin.AbortStatus} */
  54.     const abortStatus = {
  55.       canceled: false,
  56.       timedOut: false,
  57.     };
  59.     const pendingRequest = shaka.net.HttpFetchPlugin.request_(
  60.         uri, requestType, init, abortStatus, progressUpdated, headersReceived,
  61.         request.streamDataCallback);
  63.     /** @type {!shaka.util.AbortableOperation} */
  64.     const op = new shaka.util.AbortableOperation(pendingRequest, () => {
  65.       abortStatus.canceled = true;
  66.       controller.abort();
  67.       return Promise.resolve();
  68.     });
  70.     // The fetch API does not timeout natively, so do a timeout manually using
  71.     // the AbortController.
  72.     const timeoutMs = request.retryParameters.timeout;
  73.     if (timeoutMs) {
  74.       const timer = new shaka.util.Timer(() => {
  75.         abortStatus.timedOut = true;
  76.         controller.abort();
  77.       });
  79.       timer.tickAfter(timeoutMs / 1000);
  81.       // To avoid calling |abort| on the network request after it finished, we
  82.       // will stop the timer when the requests resolves/rejects.
  83.       op.finally(() => {
  84.         timer.stop();
  85.       });
  86.     }
  88.     return op;
  89.   }
  91.   /**
  92.    * @param {string} uri
  93.    * @param {shaka.net.NetworkingEngine.RequestType} requestType
  94.    * @param {!RequestInit} init
  95.    * @param {shaka.net.HttpFetchPlugin.AbortStatus} abortStatus
  96.    * @param {shaka.extern.ProgressUpdated} progressUpdated
  97.    * @param {shaka.extern.HeadersReceived} headersReceived
  98.    * @param {?function(BufferSource):!Promise} streamDataCallback
  99.    * @return {!Promise<!shaka.extern.Response>}
  100.    * @private
  101.    */
  102.   static async request_(uri, requestType, init, abortStatus, progressUpdated,
  103.       headersReceived, streamDataCallback) {
  104.     const fetch = shaka.net.HttpFetchPlugin.fetch_;
  105.     const ReadableStream = shaka.net.HttpFetchPlugin.ReadableStream_;
  106.     let response;
  107.     let arrayBuffer;
  108.     let loaded = 0;
  109.     let lastLoaded = 0;
  111.     // Last time stamp when we got a progress event.
  112.     let lastTime = Date.now();
  114.     try {
  115.       // The promise returned by fetch resolves as soon as the HTTP response
  116.       // headers are available. The download itself isn't done until the promise
  117.       // for retrieving the data (arrayBuffer, blob, etc) has resolved.
  118.       response = await fetch(uri, init);
  119.       // At this point in the process, we have the headers of the response, but
  120.       // not the body yet.
  121.       headersReceived(shaka.net.HttpFetchPlugin.headersToGenericObject_(
  122.           response.headers));
  123.       // Getting the reader in this way allows us to observe the process of
  124.       // downloading the body, instead of just waiting for an opaque promise to
  125.       // resolve.
  126.       // We first clone the response because calling getReader locks the body
  127.       // stream; if we didn't clone it here, we would be unable to get the
  128.       // response's arrayBuffer later.
  129.       const reader = response.clone().body.getReader();
  131.       const contentLengthRaw = response.headers.get('Content-Length');
  132.       const contentLength =
  133.           contentLengthRaw ? parseInt(contentLengthRaw, 10) : 0;
  135.       const start = (controller) => {
  136.         const push = async () => {
  137.           let readObj;
  138.           try {
  139.             readObj = await reader.read();
  140.           } catch (e) {
  141.             // If we abort the request, we'll get an error here.  Just ignore it
  142.             // since real errors will be reported when we read the buffer below.
  143.             shaka.log.v1('error reading from stream', e.message);
  144.             return;
  145.           }
  147.           if (!readObj.done) {
  148.             loaded += readObj.value.byteLength;
  149.             if (streamDataCallback) {
  150.               await streamDataCallback(readObj.value);
  151.             }
  152.           }
  154.           const currentTime = Date.now();
  155.           // If the time between last time and this time we got progress event
  156.           // is long enough, or if a whole segment is downloaded, call
  157.           // progressUpdated().
  158.           if (currentTime - lastTime > 100 || readObj.done) {
  159.             progressUpdated(currentTime - lastTime, loaded - lastLoaded,
  160.                 contentLength - loaded);
  161.             lastLoaded = loaded;
  162.             lastTime = currentTime;
  163.           }
  165.           if (readObj.done) {
  166.             goog.asserts.assert(!readObj.value,
  167.                 'readObj should be unset when "done" is true.');
  168.             controller.close();
  169.           } else {
  170.             controller.enqueue(readObj.value);
  171.             push();
  172.           }
  173.         };
  174.         push();
  175.       };
  176.       // Create a ReadableStream to use the reader. We don't need to use the
  177.       // actual stream for anything, though, as we are using the response's
  178.       // arrayBuffer method to get the body, so we don't store the
  179.       // ReadableStream.
  180.       new ReadableStream({start}); // eslint-disable-line no-new
  181.       arrayBuffer = await response.arrayBuffer();
  182.     } catch (error) {
  183.       if (abortStatus.canceled) {
  184.         throw new shaka.util.Error(
  185.             shaka.util.Error.Severity.RECOVERABLE,
  186.             shaka.util.Error.Category.NETWORK,
  187.             shaka.util.Error.Code.OPERATION_ABORTED,
  188.             uri, requestType);
  189.       } else if (abortStatus.timedOut) {
  190.         throw new shaka.util.Error(
  191.             shaka.util.Error.Severity.RECOVERABLE,
  192.             shaka.util.Error.Category.NETWORK,
  193.             shaka.util.Error.Code.TIMEOUT,
  194.             uri, requestType);
  195.       } else {
  196.         throw new shaka.util.Error(
  197.             shaka.util.Error.Severity.RECOVERABLE,
  198.             shaka.util.Error.Category.NETWORK,
  199.             shaka.util.Error.Code.HTTP_ERROR,
  200.             uri, error, requestType);
  201.       }
  202.     }
  204.     const headers = shaka.net.HttpFetchPlugin.headersToGenericObject_(
  205.         response.headers);
  207.     return shaka.net.HttpPluginUtils.makeResponse(
  208.         headers, arrayBuffer, response.status, uri, response.url, requestType);
  209.   }
  211.   /**
  212.    * @param {!Headers} headers
  213.    * @return {!Object.<string, string>}
  214.    * @private
  215.    */
  216.   static headersToGenericObject_(headers) {
  217.     const headersObj = {};
  218.     headers.forEach((value, key) => {
  219.       // Since Edge incorrectly return the header with a leading new line
  220.       // character ('\n'), we trim the header here.
  221.       headersObj[key.trim()] = value;
  222.     });
  223.     return headersObj;
  224.   }
  226.   /**
  227.    * Determine if the Fetch API is supported in the browser. Note: this is
  228.    * deliberately exposed as a method to allow the client app to use the same
  229.    * logic as Shaka when determining support.
  230.    * @return {boolean}
  231.    * @export
  232.    */
  233.   static isSupported() {
  234.     // On Edge, ReadableStream exists, but attempting to construct it results in
  235.     // an error. See https://bit.ly/2zwaFLL
  236.     // So this has to check that ReadableStream is present AND usable.
  237.     if (window.ReadableStream) {
  238.       try {
  239.         new ReadableStream({}); // eslint-disable-line no-new
  240.       } catch (e) {
  241.         return false;
  242.       }
  243.     } else {
  244.       return false;
  245.     }
  246.     return !!(window.fetch && window.AbortController);
  247.   }
  248. };
  251. /**
  252.  * @typedef {{
  253.  *   canceled: boolean,
  254.  *   timedOut: boolean
  255.  * }}
  256.  * @property {boolean} canceled
  257.  *   Indicates if the request was canceled.
  258.  * @property {boolean} timedOut
  259.  *   Indicates if the request timed out.
  260.  */
  261. shaka.net.HttpFetchPlugin.AbortStatus;
  264. /**
  265.  * Overridden in unit tests, but compiled out in production.
  266.  *
  267.  * @const {function(string, !RequestInit)}
  268.  * @private
  269.  */
  270. shaka.net.HttpFetchPlugin.fetch_ = window.fetch;
  273. /**
  274.  * Overridden in unit tests, but compiled out in production.
  275.  *
  276.  * @const {function(new: AbortController)}
  277.  * @private
  278.  */
  279. shaka.net.HttpFetchPlugin.AbortController_ = window.AbortController;
  282. /**
  283.  * Overridden in unit tests, but compiled out in production.
  284.  *
  285.  * @const {function(new: ReadableStream, !Object)}
  286.  * @private
  287.  */
  288. shaka.net.HttpFetchPlugin.ReadableStream_ = window.ReadableStream;
  291. /**
  292.  * Overridden in unit tests, but compiled out in production.
  293.  *
  294.  * @const {function(new: Headers)}
  295.  * @private
  296.  */
  297. shaka.net.HttpFetchPlugin.Headers_ = window.Headers;
  300. if (shaka.net.HttpFetchPlugin.isSupported()) {
  301.   shaka.net.NetworkingEngine.registerScheme(
  302.       'http', shaka.net.HttpFetchPlugin.parse,
  303.       shaka.net.NetworkingEngine.PluginPriority.PREFERRED,
  304.       /* progressSupport= */ true);
  305.   shaka.net.NetworkingEngine.registerScheme(
  306.       'https', shaka.net.HttpFetchPlugin.parse,
  307.       shaka.net.NetworkingEngine.PluginPriority.PREFERRED,
  308.       /* progressSupport= */ true);
  309.   shaka.net.NetworkingEngine.registerScheme(
  310.       'blob', shaka.net.HttpFetchPlugin.parse,
  311.       shaka.net.NetworkingEngine.PluginPriority.PREFERRED,
  312.       /* progressSupport= */ true);
  313. }