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.    * @param {shaka.extern.SchemePluginConfig} config
  33.    * @return {!shaka.extern.IAbortableOperation.<shaka.extern.Response>}
  34.    * @export
  35.    */
  36.   static parse(uri, request, requestType, progressUpdated, headersReceived,
  37.       config) {
  38.     const headers = new shaka.net.HttpFetchPlugin.Headers_();
  39.     shaka.util.MapUtils.asMap(request.headers).forEach((value, key) => {
  40.       headers.append(key, value);
  41.     });
  43.     const controller = new shaka.net.HttpFetchPlugin.AbortController_();
  45.     /** @type {!RequestInit} */
  46.     const init = {
  47.       // Edge does not treat null as undefined for body; https://bit.ly/2luyE6x
  48.       body: request.body || undefined,
  49.       headers: headers,
  50.       method: request.method,
  51.       signal: controller.signal,
  52.       credentials: request.allowCrossSiteCredentials ? 'include' : undefined,
  53.     };
  55.     /** @type {shaka.net.HttpFetchPlugin.AbortStatus} */
  56.     const abortStatus = {
  57.       canceled: false,
  58.       timedOut: false,
  59.     };
  61.     const minBytes = config.minBytesForProgressEvents || 0;
  63.     const pendingRequest = shaka.net.HttpFetchPlugin.request_(
  64.         uri, requestType, init, abortStatus, progressUpdated, headersReceived,
  65.         request.streamDataCallback, minBytes);
  67.     /** @type {!shaka.util.AbortableOperation} */
  68.     const op = new shaka.util.AbortableOperation(pendingRequest, () => {
  69.       abortStatus.canceled = true;
  70.       controller.abort();
  71.       return Promise.resolve();
  72.     });
  74.     // The fetch API does not timeout natively, so do a timeout manually using
  75.     // the AbortController.
  76.     const timeoutMs = request.retryParameters.timeout;
  77.     if (timeoutMs) {
  78.       const timer = new shaka.util.Timer(() => {
  79.         abortStatus.timedOut = true;
  80.         controller.abort();
  81.       });
  83.       timer.tickAfter(timeoutMs / 1000);
  85.       // To avoid calling |abort| on the network request after it finished, we
  86.       // will stop the timer when the requests resolves/rejects.
  87.       op.finally(() => {
  88.         timer.stop();
  89.       });
  90.     }
  92.     return op;
  93.   }
  95.   /**
  96.    * @param {string} uri
  97.    * @param {shaka.net.NetworkingEngine.RequestType} requestType
  98.    * @param {!RequestInit} init
  99.    * @param {shaka.net.HttpFetchPlugin.AbortStatus} abortStatus
  100.    * @param {shaka.extern.ProgressUpdated} progressUpdated
  101.    * @param {shaka.extern.HeadersReceived} headersReceived
  102.    * @param {?function(BufferSource):!Promise} streamDataCallback
  103.    * @param {number} minBytes
  104.    * @return {!Promise<!shaka.extern.Response>}
  105.    * @private
  106.    */
  107.   static async request_(uri, requestType, init, abortStatus, progressUpdated,
  108.       headersReceived, streamDataCallback, minBytes) {
  109.     const fetch = shaka.net.HttpFetchPlugin.fetch_;
  110.     const ReadableStream = shaka.net.HttpFetchPlugin.ReadableStream_;
  111.     let response;
  112.     let arrayBuffer = new ArrayBuffer(0);
  113.     let loaded = 0;
  114.     let lastLoaded = 0;
  116.     // Last time stamp when we got a progress event.
  117.     let lastTime = Date.now();
  119.     try {
  120.       // The promise returned by fetch resolves as soon as the HTTP response
  121.       // headers are available. The download itself isn't done until the promise
  122.       // for retrieving the data (arrayBuffer, blob, etc) has resolved.
  123.       response = await fetch(uri, init);
  124.       // At this point in the process, we have the headers of the response, but
  125.       // not the body yet.
  126.       headersReceived(shaka.net.HttpFetchPlugin.headersToGenericObject_(
  127.           response.headers));
  129.       // In new versions of Chromium, HEAD requests now have a response body
  130.       // that is null.
  131.       // So just don't try to download the body at all, if it's a HEAD request,
  132.       // to avoid null reference errors.
  133.       // See: https://crbug.com/1297060
  134.       if (init.method != 'HEAD') {
  135.         goog.asserts.assert(response.body,
  136.             'non-HEAD responses should have a body');
  138.         // Getting the reader in this way allows us to observe the process of
  139.         // downloading the body, instead of just waiting for an opaque promise
  140.         // to resolve.
  141.         // We first clone the response because calling getReader locks the body
  142.         // stream; if we didn't clone it here, we would be unable to get the
  143.         // response's arrayBuffer later.
  144.         const reader = response.clone().body.getReader();
  146.         const contentLengthRaw = response.headers.get('Content-Length');
  147.         const contentLength =
  148.             contentLengthRaw ? parseInt(contentLengthRaw, 10) : 0;
  150.         const start = (controller) => {
  151.           const push = async () => {
  152.             let readObj;
  153.             try {
  154.               readObj = await reader.read();
  155.             } catch (e) {
  156.               // If we abort the request, we'll get an error here.  Just ignore
  157.               // it since real errors will be reported when we read the buffer
  158.               // below.
  159.               shaka.log.v1('error reading from stream', e.message);
  160.               return;
  161.             }
  163.             if (!readObj.done) {
  164.               loaded += readObj.value.byteLength;
  165.               if (streamDataCallback) {
  166.                 await streamDataCallback(readObj.value);
  167.               }
  168.             }
  170.             const currentTime = Date.now();
  171.             const chunkSize = loaded - lastLoaded;
  172.             // If the time between last time and this time we got progress event
  173.             // is long enough, or if a whole segment is downloaded, call
  174.             // progressUpdated().
  175.             if ((currentTime - lastTime > 100 && chunkSize >= minBytes) ||
  176.                 readObj.done) {
  177.               const numBytesRemaining =
  178.                   readObj.done ? 0 : contentLength - loaded;
  179.               progressUpdated(currentTime - lastTime, chunkSize,
  180.                   numBytesRemaining);
  181.               lastLoaded = loaded;
  182.               lastTime = currentTime;
  183.             }
  185.             if (readObj.done) {
  186.               goog.asserts.assert(!readObj.value,
  187.                   'readObj should be unset when "done" is true.');
  188.               controller.close();
  189.             } else {
  190.               controller.enqueue(readObj.value);
  191.               push();
  192.             }
  193.           };
  194.           push();
  195.         };
  196.         // Create a ReadableStream to use the reader. We don't need to use the
  197.         // actual stream for anything, though, as we are using the response's
  198.         // arrayBuffer method to get the body, so we don't store the
  199.         // ReadableStream.
  200.         new ReadableStream({start}); // eslint-disable-line no-new
  201.         arrayBuffer = await response.arrayBuffer();
  202.       }
  203.     } catch (error) {
  204.       if (abortStatus.canceled) {
  205.         throw new shaka.util.Error(
  206.             shaka.util.Error.Severity.RECOVERABLE,
  207.             shaka.util.Error.Category.NETWORK,
  208.             shaka.util.Error.Code.OPERATION_ABORTED,
  209.             uri, requestType);
  210.       } else if (abortStatus.timedOut) {
  211.         throw new shaka.util.Error(
  212.             shaka.util.Error.Severity.RECOVERABLE,
  213.             shaka.util.Error.Category.NETWORK,
  214.             shaka.util.Error.Code.TIMEOUT,
  215.             uri, requestType);
  216.       } else {
  217.         throw new shaka.util.Error(
  218.             shaka.util.Error.Severity.RECOVERABLE,
  219.             shaka.util.Error.Category.NETWORK,
  220.             shaka.util.Error.Code.HTTP_ERROR,
  221.             uri, error, requestType);
  222.       }
  223.     }
  225.     const headers = shaka.net.HttpFetchPlugin.headersToGenericObject_(
  226.         response.headers);
  228.     return shaka.net.HttpPluginUtils.makeResponse(
  229.         headers, arrayBuffer, response.status, uri, response.url, requestType);
  230.   }
  232.   /**
  233.    * @param {!Headers} headers
  234.    * @return {!Object.<string, string>}
  235.    * @private
  236.    */
  237.   static headersToGenericObject_(headers) {
  238.     const headersObj = {};
  239.     headers.forEach((value, key) => {
  240.       // Since Edge incorrectly return the header with a leading new line
  241.       // character ('\n'), we trim the header here.
  242.       headersObj[key.trim()] = value;
  243.     });
  244.     return headersObj;
  245.   }
  247.   /**
  248.    * Determine if the Fetch API is supported in the browser. Note: this is
  249.    * deliberately exposed as a method to allow the client app to use the same
  250.    * logic as Shaka when determining support.
  251.    * @return {boolean}
  252.    * @export
  253.    */
  254.   static isSupported() {
  255.     // On Edge, ReadableStream exists, but attempting to construct it results in
  256.     // an error. See https://bit.ly/2zwaFLL
  257.     // So this has to check that ReadableStream is present AND usable.
  258.     if (window.ReadableStream) {
  259.       try {
  260.         new ReadableStream({}); // eslint-disable-line no-new
  261.       } catch (e) {
  262.         return false;
  263.       }
  264.     } else {
  265.       return false;
  266.     }
  267.     // Old fetch implementations hasn't body and ReadableStream implementation
  268.     // See: https://github.com/shaka-project/shaka-player/issues/5088
  269.     if (window.Response) {
  270.       const response = new Response('');
  271.       if (!response.body) {
  272.         return false;
  273.       }
  274.     } else {
  275.       return false;
  276.     }
  277.     return !!(window.fetch && !('polyfill' in window.fetch) &&
  278.       window.AbortController);
  279.   }
  280. };
  283. /**
  284.  * @typedef {{
  285.  *   canceled: boolean,
  286.  *   timedOut: boolean
  287.  * }}
  288.  * @property {boolean} canceled
  289.  *   Indicates if the request was canceled.
  290.  * @property {boolean} timedOut
  291.  *   Indicates if the request timed out.
  292.  */
  293. shaka.net.HttpFetchPlugin.AbortStatus;
  296. /**
  297.  * Overridden in unit tests, but compiled out in production.
  298.  *
  299.  * @const {function(string, !RequestInit)}
  300.  * @private
  301.  */
  302. shaka.net.HttpFetchPlugin.fetch_ = window.fetch;
  305. /**
  306.  * Overridden in unit tests, but compiled out in production.
  307.  *
  308.  * @const {function(new: AbortController)}
  309.  * @private
  310.  */
  311. shaka.net.HttpFetchPlugin.AbortController_ = window.AbortController;
  314. /**
  315.  * Overridden in unit tests, but compiled out in production.
  316.  *
  317.  * @const {function(new: ReadableStream, !Object)}
  318.  * @private
  319.  */
  320. shaka.net.HttpFetchPlugin.ReadableStream_ = window.ReadableStream;
  323. /**
  324.  * Overridden in unit tests, but compiled out in production.
  325.  *
  326.  * @const {function(new: Headers)}
  327.  * @private
  328.  */
  329. shaka.net.HttpFetchPlugin.Headers_ = window.Headers;
  332. if (shaka.net.HttpFetchPlugin.isSupported()) {
  333.   shaka.net.NetworkingEngine.registerScheme(
  334.       'http', shaka.net.HttpFetchPlugin.parse,
  335.       shaka.net.NetworkingEngine.PluginPriority.PREFERRED,
  336.       /* progressSupport= */ true);
  337.   shaka.net.NetworkingEngine.registerScheme(
  338.       'https', shaka.net.HttpFetchPlugin.parse,
  339.       shaka.net.NetworkingEngine.PluginPriority.PREFERRED,
  340.       /* progressSupport= */ true);
  341.   shaka.net.NetworkingEngine.registerScheme(
  342.       'blob', shaka.net.HttpFetchPlugin.parse,
  343.       shaka.net.NetworkingEngine.PluginPriority.PREFERRED,
  344.       /* progressSupport= */ true);
  345. }