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