catch all unhandled promise rejection for http browser io handler (tensorflow#1455)

* add try catch to all await call

* added accept header for request and response header check

* fix error message

* WIP wrap the fetch func with global catch

* fixed header being shared between requests

* fix node.js missing Header class error

* fix node.js error

* remove use of Response

* fixed weight load test failure

* addressed comments

* more changes for comments

* add the any type back

* address comments

* remove lint line

Author: pyu10055

src/io/browser_http.ts

@@ -49,17 +49,22 @@ export class BrowserHTTPRequest implements IOHandler {
       }
       // Make sure fetch is always bound to window (the
       // original object) when available.
-      this.fetchFunc =
-          fetch.bind(typeof window === 'undefined' ? null : window);
+      fetchFunc = fetch.bind(typeof window === 'undefined' ? null : window);
     } else {
       assert(
           typeof fetchFunc === 'function',
           'Must pass a function that matches the signature of ' +
               '`fetch` (see ' +
               'https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API)');
-      this.fetchFunc = fetchFunc;
     }
 
+    this.fetchFunc = (path: string, requestInits: RequestInit) => {
+      // tslint:disable-next-line:no-any
+      return fetchFunc(path, requestInits).catch((error: any) => {
+        throw new Error(`Request for ${path} failed due to error: ${error}`);
+      });
+    };
+
     assert(
         path != null && path.length > 0,
         'URL path for browserHTTPRequest must not be null, undefined or ' +
@@ -145,26 +150,44 @@ export class BrowserHTTPRequest implements IOHandler {
    * Loads the model topology file and build the in memory graph of the model.
    */
   private async loadBinaryTopology(): Promise<ArrayBuffer> {
-    try {
-      const response =
-          await this.getFetchFunc()(this.path[0], this.requestInit);
-      if (!response.ok) {
-        throw new Error(
-            `BrowserHTTPRequest.load() failed due to HTTP response: ${
-                response.statusText}`);
-      }
-      return await response.arrayBuffer();
-    } catch (error) {
-      throw new Error(`${this.path[0]} not found. ${error}`);
+    const response = await this.getFetchFunc()(
+        this.path[0], this.addAcceptHeader('application/octet-stream'));
+    this.verifyContentType(
+        response, 'model topology', 'application/octet-stream');
+
+    if (!response.ok) {
+      throw new Error(`Request to ${this.path[0]} failed with error: ${
+          response.statusText}`);
+    }
+    return await response.arrayBuffer();
+  }
+
+  private addAcceptHeader(mimeType: string): RequestInit {
+    const requestOptions = Object.assign({}, this.requestInit || {});
+    const headers = Object.assign({}, requestOptions.headers || {});
+    // tslint:disable-next-line:no-any
+    (headers as any)['Accept'] = mimeType;
+    requestOptions.headers = headers;
+    return requestOptions;
+  }
+
+  private verifyContentType(response: Response, target: string, type: string) {
+    const contentType = response.headers.get('content-type');
+    if (!contentType || contentType.indexOf(type) === -1) {
+      throw new Error(`Request to ${response.url} for ${
+          target} failed. Expected content type ${type} but got ${
+          contentType}.`);
     }
   }
 
   protected async loadBinaryModel(): Promise<ModelArtifacts> {
     const graphPromise = this.loadBinaryTopology();
-    const manifestPromise =
-        await this.getFetchFunc()(this.path[1], this.requestInit);
+    const manifestPromise = await this.getFetchFunc()(
+        this.path[1], this.addAcceptHeader('application/json'));
+    this.verifyContentType(
+        manifestPromise, 'weights manifest', 'application/json');
     if (!manifestPromise.ok) {
-      throw new Error(`BrowserHTTPRequest.load() failed due to HTTP response: ${
+      throw new Error(`Request to ${this.path[1]} failed with error: ${
           manifestPromise.statusText}`);
     }
 
@@ -185,10 +208,13 @@ export class BrowserHTTPRequest implements IOHandler {
   }
 
   protected async loadJSONModel(): Promise<ModelArtifacts> {
-    const modelConfigRequest =
-        await this.getFetchFunc()(this.path as string, this.requestInit);
+    const modelConfigRequest = await this.getFetchFunc()(
+        this.path as string, this.addAcceptHeader('application/json'));
+    this.verifyContentType(
+        modelConfigRequest, 'model topology', 'application/json');
+
     if (!modelConfigRequest.ok) {
-      throw new Error(`BrowserHTTPRequest.load() failed due to HTTP response: ${
+      throw new Error(`Request to ${this.path} failed with error: ${
           modelConfigRequest.statusText}`);
     }
     const modelConfig = await modelConfigRequest.json();
@@ -231,12 +257,10 @@ export class BrowserHTTPRequest implements IOHandler {
         fetchURLs.push(pathPrefix + path + suffix);
       });
     });
-
     return [
       weightSpecs,
       concatenateArrayBuffers(await loadWeightsAsArrayBuffer(
-          fetchURLs, this.requestInit, this.getFetchFunc(),
-          this.onProgress))
+          fetchURLs, this.requestInit, this.getFetchFunc(), this.onProgress))
     ];
   }
 
@@ -276,24 +300,25 @@ export function isHTTPScheme(url: string): boolean {
   return url.match(BrowserHTTPRequest.URL_SCHEME_REGEX) != null;
 }
 
-export const httpRequestRouter: IORouter = (url: string|string[], onProgress?: Function) => {
-  if (typeof fetch === 'undefined') {
-    // browserHTTPRequest uses `fetch`, if one wants to use it in node.js
-    // they have to setup a global fetch polyfill.
-    return null;
-  } else {
-    let isHTTP = true;
-    if (Array.isArray(url)) {
-      isHTTP = url.every(urlItem => isHTTPScheme(urlItem));
-    } else {
-      isHTTP = isHTTPScheme(url);
-    }
-    if (isHTTP) {
-      return browserHTTPRequest(url, null, null, null, onProgress);
-    }
-  }
-  return null;
-};
+export const httpRequestRouter: IORouter =
+    (url: string|string[], onProgress?: Function) => {
+      if (typeof fetch === 'undefined') {
+        // browserHTTPRequest uses `fetch`, if one wants to use it in node.js
+        // they have to setup a global fetch polyfill.
+        return null;
+      } else {
+        let isHTTP = true;
+        if (Array.isArray(url)) {
+          isHTTP = url.every(urlItem => isHTTPScheme(urlItem));
+        } else {
+          isHTTP = isHTTPScheme(url);
+        }
+        if (isHTTP) {
+          return browserHTTPRequest(url, null, null, null, onProgress);
+        }
+      }
+      return null;
+    };
 IORouterRegistry.registerSaveRouter(httpRequestRouter);
 IORouterRegistry.registerLoadRouter(httpRequestRouter);
 
@@ -444,6 +469,6 @@ IORouterRegistry.registerLoadRouter(httpRequestRouter);
 export function browserHTTPRequest(
     path: string|string[], requestInit?: RequestInit, weightPathPrefix?: string,
     fetchFunc?: Function, onProgress?: Function): IOHandler {
-  return new BrowserHTTPRequest(path, requestInit, weightPathPrefix, fetchFunc,
-      onProgress);
+  return new BrowserHTTPRequest(
+      path, requestInit, weightPathPrefix, fetchFunc, onProgress);
 }