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