Add http2-push support

Added support for pushing files with h2 requests, including CLI flags:

  -m, --manifest string        Path to h2-push manifest

Usage:
  1. Generate push manifest with http2-push-manifest node module
  2. Run: polyserve -m push_manifest.json -h h2

Author: tony19

package.json

@@ -22,6 +22,7 @@
     "command-line-args": "^2.1.6",
     "express": "^4.8.5",
     "find-port": "^1.0.1",
+    "mime": "^1.3.4",
     "mz": "^2.4.0",
     "opn": "^3.0.2",
     "pem": "^1.8.3",

src/args.ts

@@ -93,4 +93,10 @@ export let args : ArgDescriptor[] = [
     defaultValue: 'cert.pem',
     type: String,
   },
+  {
+    name: 'manifest',
+    alias: 'm',
+    description: 'Path to h2-push manifest',
+    type: String,
+  },
 ];

src/cli.ts

@@ -44,6 +44,7 @@ export function run(): Promise<void> {
       protocol: cliOptions['protocol'],
       keyPath: cliOptions['key'],
       certPath: cliOptions['cert'],
+      pushManifestPath: cliOptions['manifest'],
     };
 
     if (cliOptions.help) {

src/start_server.ts

@@ -10,8 +10,10 @@
 
 'use strict';
 
+import * as assert from 'assert';
 import * as express from 'express';
 import * as findPort from 'find-port';
+import * as mime from 'mime';
 // TODO: Switch to node-http2 when compatible with express
 // https://github.com/molnarg/node-http2/issues/100
 import * as http from 'spdy';
@@ -24,6 +26,9 @@ import * as fs from 'mz/fs';
 
 import { makeApp } from './make_app';
 
+/** h2 push manifest cache */
+let _pushManifest = {};
+
 export interface ServerOptions {
 
   /** The root directory to serve **/
@@ -58,6 +63,9 @@ export interface ServerOptions {
 
   /** Path to TLS certificate for HTTPS */
   certPath?: string;
+
+  /** Path to H2 push-manifest file */
+  pushManifestPath?: string;
 }
 
 function applyDefaultOptions(options: ServerOptions): ServerOptions {
@@ -121,9 +129,17 @@ export function getApp(options: ServerOptions) {
 
   app.use('/components/', polyserve);
 
+  // Preload the h2-push manifest to avoid the cost on first push
+  if (options.pushManifestPath) {
+    getPushManifest(options.root, options.pushManifestPath);
+  }
+
   app.get('/*', (req, res) => {
+
+    pushResources(options, req, res);
+
     let filePath = req.path;
-    send(req, filePath, {root: root,})
+    send(req, filePath, {root: root})
       .on('error', (error: send.SendError) => {
         if ((error).status == 404 && !filePath.endsWith('.html')) {
           send(req, '/', {root: root}).pipe(res);
@@ -340,3 +356,82 @@ function startWithPort(userOptions: ServerOptions): Promise<http.Server> {
         })
       );
 }
+
+/**
+ * Asserts file existence for all specified files in a push-manifest
+ * @param {string} root path to root directory
+ * @param {string} manifest manifest object
+ */
+function assertValidManifest(root: string, manifest: {[path: string]: any}) {
+
+  function assertExists(filename: string) {
+    const fname = path.join(root, filename);
+    try {
+      // fs.statSync also verifies file existence
+      assert(fs.statSync(fname).isFile(), `file not found: ${fname}`);
+    } catch (err) {
+      console.error('invalid h2-push manifest');
+      throw err;
+    }
+  }
+
+  for (const refFile of Object.keys(manifest)) {
+    assertExists(refFile);
+    for (const pushFile of Object.keys(manifest[refFile])) {
+      assertExists(pushFile);
+    }
+  }
+}
+
+/**
+ * Reads a push-manifest from the specified path, or a cached version
+ * of the file
+ * @param {string} root path to root directory
+ * @param {string} manifestPath path to manifest file
+ * @returns {any} the manifest
+ */
+function getPushManifest(root: string, manifestPath: string): {[path: string]: any} {
+  if (!_pushManifest[manifestPath]) {
+    const data = fs.readFileSync(manifestPath);
+    const manifest = JSON.parse(data.toString());
+    assertValidManifest(root, manifest);
+    _pushManifest[manifestPath] = manifest;
+  }
+  return _pushManifest[manifestPath];
+}
+
+/**
+ * Pushes any resources for the requested file
+ * @param options server options
+ * @param req HTTP request
+ * @param res HTTP response
+ */
+function pushResources(options: ServerOptions, req: any, res: any) {
+  if (res.push
+      && options.protocol === 'h2'
+      && options.pushManifestPath
+      && !req.get('x-is-push')) {
+
+    const pushManifest = getPushManifest(options.root, options.pushManifestPath);
+    const resources = pushManifest[req.path];
+    if (resources) {
+      const root = options.root;
+      for (const filename of Object.keys(resources)) {
+        const stream: NodeJS.WritableStream = res.push(filename,
+          {
+            request: {
+             accept: '*/*'
+            },
+            response: {
+             'content-type': mime.lookup(filename),
+
+             // Add an X-header to the pushed request so we don't trigger pushes for pushes
+             'x-is-push': 'true'
+            }
+          })
+          .on('error', (err: any) => console.error('failed to push', filename, err));
+        fs.createReadStream(path.join(root, filename)).pipe(stream);
+      }
+    }
+  }
+}