feat(http-server): add http/2 support based on spdy

packages/http-server/package.json

@@ -17,7 +17,9 @@
  "copyright.owner": "IBM Corp.",
  "license": "MIT",
  "dependencies": {
- "p-event": "^2.0.0"
+ "@types/spdy": "^3.4.4",
+ "p-event": "^2.0.0",
+ "spdy": "^4.0.0"
  },
  "devDependencies": {
  "@loopback/build": "^1.0.1",

packages/http-server/src/http-server.ts

@@ -3,12 +3,12 @@
 // This file is licensed under the MIT License.
 // License text available at https://opensource.org/licenses/MIT
 
-import {IncomingMessage, ServerResponse} from 'http';
 import * as http from 'http';
+import {IncomingMessage, ServerResponse} from 'http';
 import * as https from 'https';
 import {AddressInfo} from 'net';
-
 import * as pEvent from 'p-event';
+import * as spdy from 'spdy';
 
 export type RequestListener = (
  req: IncomingMessage,
@@ -46,21 +46,28 @@ export interface HttpsOptions extends ListenerOptions, https.ServerOptions {
  protocol: 'https';
 }
 
+/**
+ * HTTP/2 server options based on `spdy`
+ */
+export interface Http2Options extends ListenerOptions, spdy.ServerOptions {
+ protocol: 'http2' | 'https';
+}
+
 /**
  * Possible server options
  *
  * @export
  * @type HttpServerOptions
  */
-export type HttpServerOptions = HttpOptions | HttpsOptions;
+export type HttpServerOptions = HttpOptions | HttpsOptions | Http2Options;
 
 /**
  * Supported protocols
  *
  * @export
  * @type HttpProtocol
  */
-export type HttpProtocol = 'http' | 'https'; // Will be extended to `http2` in the future
+export type HttpProtocol = 'http' | 'https' | 'http2';
 
 /**
  * HTTP / HTTPS server used by LoopBack's RestServer
@@ -84,14 +91,22 @@ export class HttpServer {
  */
  constructor(
  requestListener: RequestListener,
- serverOptions?: HttpServerOptions,
+ serverOptions: HttpServerOptions = {},
  ) {
  this.requestListener = requestListener;
  this.serverOptions = serverOptions;
  this._port = serverOptions ? serverOptions.port || 0 : 0;
  this._host = serverOptions ? serverOptions.host : undefined;
  this._protocol = serverOptions ? serverOptions.protocol || 'http' : 'http';
- if (this._protocol === 'https') {
+ if (
+ this._protocol === 'http2' ||
+ (this._protocol === 'https' && serverOptions.hasOwnProperty('spdy'))
+ ) {
+ this.server = spdy.createServer(
+ this.serverOptions as spdy.ServerOptions,
+ this.requestListener,
+ );
+ } else if (this._protocol === 'https') {
  this.server = https.createServer(
  this.serverOptions as https.ServerOptions,
  this.requestListener,
@@ -116,8 +131,14 @@ export class HttpServer {
  */
  public async stop() {
  if (!this.server) return;
- this.server.close();
- await pEvent(this.server, 'close');
+ if (!this.server.listening) return;
+ await new Promise<void>((resolve, reject) => {
+ this.server.close((err: unknown) => {
+ if (!err) resolve();
+ else reject(err);
+ });
+ });
+
  this._listening = false;
  }
 
@@ -153,7 +174,8 @@ export class HttpServer {
  } else if (host === '0.0.0.0') {
  host = '127.0.0.1';
  }
- return `${this._protocol}://${host}:${this.port}`;
+ const protocol = this._protocol === 'http2' ? 'https' : this._protocol;
+ return `${protocol}://${host}:${this.port}`;
  }
 
  /**

packages/http-server/test/integration/http-server.integration.ts

@@ -2,19 +2,22 @@
 // Node module: @loopback/http-server
 // This file is licensed under the MIT License.
 // License text available at https://opensource.org/licenses/MIT
-import {HttpServer, HttpOptions, HttpServerOptions} from '../../';
 import {
- supertest,
  expect,
- itSkippedOnTravis,
+ givenHttpServerConfig,
  httpGetAsync,
  httpsGetAsync,
- givenHttpServerConfig,
+ itSkippedOnTravis,
+ supertest,
 } from '@loopback/testlab';
-import * as makeRequest from 'request-promise-native';
-import {IncomingMessage, ServerResponse, Server} from 'http';
-import * as path from 'path';
 import * as fs from 'fs';
+import {IncomingMessage, Server, ServerResponse} from 'http';
+import {Agent} from 'https';
+import * as path from 'path';
+import * as makeRequest from 'request-promise-native';
+import * as spdy from 'spdy';
+import {HttpOptions, HttpServer, HttpServerOptions} from '../../';
+import {Http2Options} from '../../src';
 
 describe('HttpServer (integration)', () => {
  let server: HttpServer | undefined;
@@ -156,29 +159,29 @@ describe('HttpServer (integration)', () => {
 
  it('supports HTTPS protocol with key and certificate files', async () => {
  const serverOptions = givenHttpServerConfig();
- const httpsServer: HttpServer = givenHttpsServer(serverOptions);
- await httpsServer.start();
- const response = await httpsGetAsync(httpsServer.url);
+ server = givenHttpsServer(serverOptions);
+ await server.start();
+ const response = await httpsGetAsync(server.url);
  expect(response.statusCode).to.equal(200);
  });
 
  it('supports HTTPS protocol with a pfx file', async () => {
  const serverOptions = givenHttpServerConfig({
  usePfx: true,
  });
- const httpsServer: HttpServer = givenHttpsServer(serverOptions);
- await httpsServer.start();
- const response = await httpsGetAsync(httpsServer.url);
+ server = givenHttpsServer(serverOptions);
+ await server.start();
+ const response = await httpsGetAsync(server.url);
  expect(response.statusCode).to.equal(200);
  });
 
  itSkippedOnTravis('handles IPv6 loopback address in HTTPS', async () => {
- const httpsServer: HttpServer = givenHttpsServer({
+ server = givenHttpsServer({
  host: '::1',
  });
- await httpsServer.start();
- expect(httpsServer.address!.family).to.equal('IPv6');
- const response = await httpsGetAsync(httpsServer.url);
+ await server.start();
+ expect(server.address!.family).to.equal('IPv6');
+ const response = await httpsGetAsync(server.url);
  expect(response.statusCode).to.equal(200);
  });
 
@@ -196,6 +199,42 @@ describe('HttpServer (integration)', () => {
  expect(server.url).to.equal(`http://127.0.0.1:${server.port}`);
  });
 
+ it('supports HTTP/2 protocol with key and certificate files', async () => {
+ const serverOptions: Http2Options = Object.assign(
+ {
+ protocol: 'http2' as 'http2',
+ rejectUnauthorized: false,
+ spdy: {protocols: ['h2' as 'h2']},
+ },
+ givenHttpServerConfig(),
+ );
+ server = givenHttp2Server(serverOptions);
+ await server.start();
+
+ // http2 does not have its own url scheme
+ expect(server.url).to.match(/^https\:/);
+
+ const agent = spdy.createAgent({
+ rejectUnauthorized: false,
+ port: server.port,
+ host: server.host,
+
+ // Optional SPDY options
+ spdy: {
+ plain: false,
+ ssl: true,
+ },
+ }) as Agent;
+
+ const response = await httpsGetAsync(server.url, agent);
+ expect(response.statusCode).to.equal(200);
+
+ // We need to close the agent so that server.close() returns
+ // `@types/[email protected]` is not fully compatible with `[email protected]`
+ // tslint:disable-next-line:no-any
+ (agent as any).close();
+ });
+
  function dummyRequestHandler(
  req: IncomingMessage,
  res: ServerResponse,
@@ -229,4 +268,15 @@ describe('HttpServer (integration)', () => {
  }
  return new HttpServer(dummyRequestHandler, options);
  }
+
+ function givenHttp2Server(options: Http2Options): HttpServer {
+ const certDir = path.resolve(__dirname, '../../../fixtures');
+
+ const keyPath = path.join(certDir, 'key.pem');
+ const certPath = path.join(certDir, 'cert.pem');
+ options.key = fs.readFileSync(keyPath);
+ options.cert = fs.readFileSync(certPath);
+
+ return new HttpServer(dummyRequestHandler, options);
+ }
 });

packages/testlab/src/request.ts

@@ -22,10 +22,15 @@ export function httpGetAsync(urlString: string): Promise<IncomingMessage> {
  * Async wrapper for making HTTPS GET requests
  * @param urlString
  */
-export function httpsGetAsync(urlString: string): Promise<IncomingMessage> {
- const agent = new https.Agent({
- rejectUnauthorized: false,
- });
+export function httpsGetAsync(
+ urlString: string,
+ agent?: https.Agent,
+): Promise<IncomingMessage> {
+ agent =
+ agent ||
+ new https.Agent({
+ rejectUnauthorized: false,
+ });
 
  const urlOptions = url.parse(urlString);
  const options = {agent, ...urlOptions};