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