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));
  124.       // In new versions of Chromium, HEAD requests now have a response body
  125.       // that is null.
  126.       // So just don't try to download the body at all, if it's a HEAD request,
  127.       // to avoid null reference errors.
  128.       // See: https://crbug.com/1297060
  129.       if (init.method != 'HEAD') {
  130.         goog.asserts.assert(response.body,
  131.             'non-HEAD responses should have a body');
  133.         // Getting the reader in this way allows us to observe the process of
  134.         // downloading the body, instead of just waiting for an opaque promise
  135.         // to resolve.
  136.         // We first clone the response because calling getReader locks the body
  137.         // stream; if we didn't clone it here, we would be unable to get the
  138.         // response's arrayBuffer later.
  139.         const reader = response.clone().body.getReader();
  141.         const contentLengthRaw = response.headers.get('Content-Length');
  142.         const contentLength =
  143.             contentLengthRaw ? parseInt(contentLengthRaw, 10) : 0;
  145.         const start = (controller) => {
  146.           const push = async () => {
  147.             let readObj;
  148.             try {
  149.               readObj = await reader.read();
  150.             } catch (e) {
  151.               // If we abort the request, we'll get an error here.  Just ignore
  152.               // it since real errors will be reported when we read the buffer
  153.               // below.
  154.               shaka.log.v1('error reading from stream', e.message);
  155.               return;
  156.             }
  158.             if (!readObj.done) {
  159.               loaded += readObj.value.byteLength;
  160.               if (streamDataCallback) {
  161.                 await streamDataCallback(readObj.value);
  162.               }
  163.             }
  165.             const currentTime = Date.now();
  166.             // If the time between last time and this time we got progress event
  167.             // is long enough, or if a whole segment is downloaded, call
  168.             // progressUpdated().
  169.             if (currentTime - lastTime > 100 || readObj.done) {
  170.               const numBytesRemaining =
  171.                   readObj.done ? 0 : contentLength - loaded;
  172.               progressUpdated(currentTime - lastTime, loaded - lastLoaded,
  173.                   numBytesRemaining);
  174.               lastLoaded = loaded;
  175.               lastTime = currentTime;
  176.             }
  178.             if (readObj.done) {
  179.               goog.asserts.assert(!readObj.value,
  180.                   'readObj should be unset when "done" is true.');
  181.               controller.close();
  182.             } else {
  183.               controller.enqueue(readObj.value);
  184.               push();
  185.             }
  186.           };
  187.           push();
  188.         };
  189.         // Create a ReadableStream to use the reader. We don't need to use the
  190.         // actual stream for anything, though, as we are using the response's
  191.         // arrayBuffer method to get the body, so we don't store the
  192.         // ReadableStream.
  193.         new ReadableStream({start}); // eslint-disable-line no-new
  194.         arrayBuffer = await response.arrayBuffer();
  195.       }
  196.     } catch (error) {
  197.       if (abortStatus.canceled) {
  198.         throw new shaka.util.Error(
  199.             shaka.util.Error.Severity.RECOVERABLE,
  200.             shaka.util.Error.Category.NETWORK,
  201.             shaka.util.Error.Code.OPERATION_ABORTED,
  202.             uri, requestType);
  203.       } else if (abortStatus.timedOut) {
  204.         throw new shaka.util.Error(
  205.             shaka.util.Error.Severity.RECOVERABLE,
  206.             shaka.util.Error.Category.NETWORK,
  207.             shaka.util.Error.Code.TIMEOUT,
  208.             uri, requestType);
  209.       } else {
  210.         throw new shaka.util.Error(
  211.             shaka.util.Error.Severity.RECOVERABLE,
  212.             shaka.util.Error.Category.NETWORK,
  213.             shaka.util.Error.Code.HTTP_ERROR,
  214.             uri, error, requestType);
  215.       }
  216.     }
  218.     const headers = shaka.net.HttpFetchPlugin.headersToGenericObject_(
  219.         response.headers);
  221.     return shaka.net.HttpPluginUtils.makeResponse(
  222.         headers, arrayBuffer, response.status, uri, response.url, requestType);
  223.   }
  225.   /**
  226.    * @param {!Headers} headers
  227.    * @return {!Object.<string, string>}
  228.    * @private
  229.    */
  230.   static headersToGenericObject_(headers) {
  231.     const headersObj = {};
  232.     headers.forEach((value, key) => {
  233.       // Since Edge incorrectly return the header with a leading new line
  234.       // character ('\n'), we trim the header here.
  235.       headersObj[key.trim()] = value;
  236.     });
  237.     return headersObj;
  238.   }
  240.   /**
  241.    * Determine if the Fetch API is supported in the browser. Note: this is
  242.    * deliberately exposed as a method to allow the client app to use the same
  243.    * logic as Shaka when determining support.
  244.    * @return {boolean}
  245.    * @export
  246.    */
  247.   static isSupported() {
  248.     // On Edge, ReadableStream exists, but attempting to construct it results in
  249.     // an error. See https://bit.ly/2zwaFLL
  250.     // So this has to check that ReadableStream is present AND usable.
  251.     if (window.ReadableStream) {
  252.       try {
  253.         new ReadableStream({}); // eslint-disable-line no-new
  254.       } catch (e) {
  255.         return false;
  256.       }
  257.     } else {
  258.       return false;
  259.     }
  260.     // Old fetch implementations hasn't body and ReadableStream implementation
  261.     // See: https://github.com/shaka-project/shaka-player/issues/5088
  262.     if (window.Response) {
  263.       const response = new Response('');
  264.       if (!response.body) {
  265.         return false;
  266.       }
  267.     } else {
  268.       return false;
  269.     }
  270.     return !!(window.fetch && !('polyfill' in window.fetch) &&
  271.       window.AbortController);
  272.   }
  273. };
  276. /**
  277.  * @typedef {{
  278.  *   canceled: boolean,
  279.  *   timedOut: boolean
  280.  * }}
  281.  * @property {boolean} canceled
  282.  *   Indicates if the request was canceled.
  283.  * @property {boolean} timedOut
  284.  *   Indicates if the request timed out.
  285.  */
  286. shaka.net.HttpFetchPlugin.AbortStatus;
  289. /**
  290.  * Overridden in unit tests, but compiled out in production.
  291.  *
  292.  * @const {function(string, !RequestInit)}
  293.  * @private
  294.  */
  295. shaka.net.HttpFetchPlugin.fetch_ = window.fetch;
  298. /**
  299.  * Overridden in unit tests, but compiled out in production.
  300.  *
  301.  * @const {function(new: AbortController)}
  302.  * @private
  303.  */
  304. shaka.net.HttpFetchPlugin.AbortController_ = window.AbortController;
  307. /**
  308.  * Overridden in unit tests, but compiled out in production.
  309.  *
  310.  * @const {function(new: ReadableStream, !Object)}
  311.  * @private
  312.  */
  313. shaka.net.HttpFetchPlugin.ReadableStream_ = window.ReadableStream;
  316. /**
  317.  * Overridden in unit tests, but compiled out in production.
  318.  *
  319.  * @const {function(new: Headers)}
  320.  * @private
  321.  */
  322. shaka.net.HttpFetchPlugin.Headers_ = window.Headers;
  325. if (shaka.net.HttpFetchPlugin.isSupported()) {
  326.   shaka.net.NetworkingEngine.registerScheme(
  327.       'http', shaka.net.HttpFetchPlugin.parse,
  328.       shaka.net.NetworkingEngine.PluginPriority.PREFERRED,
  329.       /* progressSupport= */ true);
  330.   shaka.net.NetworkingEngine.registerScheme(
  331.       'https', shaka.net.HttpFetchPlugin.parse,
  332.       shaka.net.NetworkingEngine.PluginPriority.PREFERRED,
  333.       /* progressSupport= */ true);
  334.   shaka.net.NetworkingEngine.registerScheme(
  335.       'blob', shaka.net.HttpFetchPlugin.parse,
  336.       shaka.net.NetworkingEngine.PluginPriority.PREFERRED,
  337.       /* progressSupport= */ true);
  338. }