Support http2.

.gitignore

@@ -8,4 +8,5 @@ test.js
 components
 test/node/fixtures/tmp.json
 .idea
-superagent.js
+superagent.js
+package-lock.json

.travis.yml

@@ -14,3 +14,10 @@ matrix:
   include:
     - node_js: "9"
       env: BROWSER=1
+    - node_js: "9"
+      env: EXPOSE_HTTP2=1
+    - node_js: "8"
+      env: EXPOSE_HTTP2=1
+
+before_install:
+  - "test -z $(echo $EXPOSE_HTTP2) || npm install --only=dev https://github.com/sogaani/express.git#initial-support-http2"

Makefile

@@ -9,7 +9,15 @@ test:
 	@if [ "x$(BROWSER)" = "x" ]; then make test-node; else make test-browser; fi
 
 test-node:
-	@NODE_ENV=test NODE_TLS_REJECT_UNAUTHORIZED=0 ./node_modules/.bin/mocha \
+	@NODE_ENV=test NODE_TLS_REJECT_UNAUTHORIZED=0 node ./node_modules/.bin/mocha \
+		--require should \
+		--trace-warnings \
+		--reporter $(REPORTER) \
+		--timeout 5000 \
+		$(NODETESTS)
+
+test-node-http2:
+	@NODE_ENV=test EXPOSE_HTTP2=1 NODE_TLS_REJECT_UNAUTHORIZED=0 node ./node_modules/.bin/mocha \
 		--require should \
 		--trace-warnings \
 		--reporter $(REPORTER) \

lib/node/http2wrapper.js

@@ -0,0 +1,186 @@
+'use strict';
+
+const http2 = require('http2');
+const Stream = require('stream');
+const util = require('util');
+const net = require('net');
+const tls = require('tls');
+const parse = require('url').parse;
+
+const {
+  HTTP2_HEADER_PATH,
+  HTTP2_HEADER_STATUS,
+  HTTP2_HEADER_METHOD,
+  HTTP2_HEADER_AUTHORITY,
+  HTTP2_HEADER_HOST,
+  HTTP2_HEADER_SET_COOKIE,
+  NGHTTP2_CANCEL,
+} = http2.constants;
+
+
+function setProtocol(protocol) {
+  return {
+    request: function (options) {
+      return new Request(protocol, options);
+    }
+  }
+}
+
+function Request(protocol, options) {
+  Stream.call(this);
+  const defaultPort = protocol === 'https' ? 443 : 80;
+  const defaultHost = 'localhost'
+  const port = options.port || defaultPort;
+  const host = options.host || defaultHost;
+
+  delete options.port
+  delete options.host
+
+  this.method = options.method;
+  this.path = options.path;
+  this.protocol = protocol;
+  this.host = host;
+
+  delete options.method
+  delete options.path
+
+  const sessionOptions = Object.assign({}, options);
+  if (options.socketPath) {
+    sessionOptions.socketPath = options.socketPath;
+    sessionOptions.createConnection = this.createUnixConnection.bind(this);
+  }
+
+  this._headers = {};
+
+  const session = http2.connect(`${protocol}://${host}:${port}`, sessionOptions);
+  this.setHeader('host', `${host}:${port}`)
+
+  session.on('error', (err) => this.emit('error', err));
+
+  this.session = session;
+}
+
+/**
+ * Inherit from `Stream` (which inherits from `EventEmitter`).
+ */
+util.inherits(Request, Stream);
+
+Request.prototype.createUnixConnection = function (authority, options) {
+  switch (this.protocol) {
+    case 'http':
+      return net.connect(options.socketPath);
+    case 'https':
+      options.ALPNProtocols = ['h2'];
+      options.servername = this.host;
+      options.allowHalfOpen = true;
+      return tls.connect(options.socketPath, options);
+    default:
+      throw new Error('Unsupported protocol', this.protocol);
+  }
+}
+
+Request.prototype.setNoDelay = function (bool) {
+  this.session.socket.setNoDelay(bool);
+}
+
+Request.prototype.getFrame = function () {
+  if (this.frame) {
+    return this.frame;
+  }
+
+  const method = {
+    [HTTP2_HEADER_PATH]: this.path,
+    [HTTP2_HEADER_METHOD]: this.method,
+  }
+
+  let headers = this.mapToHttp2Header(this._headers);
+
+  headers = Object.assign(headers, method);
+
+  const frame = this.session.request(headers);
+  frame.once('response', (headers, flags) => {
+    headers = this.mapToHttpHeader(headers);
+    frame.headers = headers;
+    frame.status = frame.statusCode = headers[HTTP2_HEADER_STATUS];
+    this.emit('response', frame);
+  });
+
+  this._headerSent = true;
+
+  frame.once('drain', () => this.emit('drain'));
+  frame.on('error', (err) => this.emit('error', err));
+  frame.on('close', () => this.session.close());
+
+  this.frame = frame;
+  return frame;
+}
+
+Request.prototype.mapToHttpHeader = function (headers) {
+  const keys = Object.keys(headers);
+  const http2Headers = {};
+  for (var i = 0; i < keys.length; i++) {
+    let key = keys[i];
+    let value = headers[key];
+    key = key.toLowerCase();
+    switch (key) {
+      case HTTP2_HEADER_SET_COOKIE:
+        value = Array.isArray(value) ? value : [value];
+        break;
+      default:
+        break;
+    }
+    http2Headers[key] = value;
+  }
+  return http2Headers;
+}
+
+Request.prototype.mapToHttp2Header = function (headers) {
+  const keys = Object.keys(headers);
+  const http2Headers = {};
+  for (var i = 0; i < keys.length; i++) {
+    let key = keys[i];
+    let value = headers[key];
+    key = key.toLowerCase();
+    switch (key) {
+      case HTTP2_HEADER_HOST:
+        key = HTTP2_HEADER_AUTHORITY;
+        value = value.startsWith('http') ? parse(value).host : value;
+        break;
+      default:
+        break;
+    }
+    http2Headers[key] = value;
+  }
+  return http2Headers;
+}
+
+Request.prototype.setHeader = function (name, value) {
+  this._headers[name.toLowerCase()] = value;
+}
+
+Request.prototype.getHeader = function (name) {
+  return this._headers[name.toLowerCase()];
+}
+
+Request.prototype.write = function (data, encoding) {
+  const frame = this.getFrame();
+  return frame.write(data, encoding);
+};
+
+Request.prototype.pipe = function (stream, options) {
+  const frame = this.getFrame();
+  return frame.pipe(stream, options);
+}
+
+Request.prototype.end = function (data) {
+  const frame = this.getFrame();
+  frame.end(data);
+}
+
+Request.prototype.abort = function (data) {
+  const frame = this.getFrame();
+  frame.close(NGHTTP2_CANCEL);
+  this.session.close();
+}
+
+exports.setProtocol = setProtocol;

lib/node/index.js

@@ -16,8 +16,8 @@ const Stream = require('stream');
 const utils = require('../utils');
 const unzip = require('./unzip').unzip;
 const mime = require('mime');
-const https = require('https');
-const http = require('http');
+let https = require('https');
+let http = require('http');
 const fs = require('fs');
 const qs = require('qs');
 const zlib = require('zlib');
@@ -82,6 +82,22 @@ exports.protocols = {
   'https:': https,
 };
 
+/**
+ * Enable http2 if supported
+ */
+
+if(process.env.EXPOSE_HTTP2){
+  try {
+    const http2 = require('./http2wrapper');
+    exports.protocols = {
+      'http:': http2.setProtocol('http'),
+      'https:': http2.setProtocol('https'),
+    };
+    console.warn('superagent: Enable experimental feature http2');
+  } catch (_) {
+  }
+}
+
 /**
  * Default serialization map.
  *
@@ -787,6 +803,9 @@ Request.prototype._emitResponse = function(body, files) {
   if (undefined !== body) {
     response.body = body;
   }
+  if (undefined === response.text && undefined !== body){
+    response.text = this._resBuffered ? null : body.toString();
+  }
   response.files = files;
   if (this._endCalled) {
     response.pipe = function() {

lib/node/unzip.js

@@ -59,9 +59,9 @@ exports.unzip = (req, res) => {
   const _on = res.on;
   res.on = function(type, fn) {
     if ('data' == type || 'end' == type) {
-      stream.on(type, fn);
+      stream.on(type, fn.bind(res));
     } else if ('error' == type) {
-      stream.on(type, fn);
+      stream.on(type, fn.bind(res));
       _on.call(res, type, fn);
     } else {
       _on.call(res, type, fn);

package.json

@@ -4,7 +4,8 @@
   "description": "elegant & feature rich browser / node HTTP with a fluent API",
   "scripts": {
     "prepare": "make all",
-    "test": "make test"
+    "test": "make test",
+    "test-http2": "make test-node-http2"
   },
   "keywords": [
     "http",

test/json.js

@@ -1,6 +1,7 @@
 const setup = require('./support/setup');
 const uri = setup.uri;
 const doesntWorkInBrowserYet = setup.NODE;
+const doesntWorkInHttp2 = !process.env.EXPOSE_HTTP2;
 
 const assert = require('assert');
 const request = require('../');
@@ -78,7 +79,7 @@ describe('req.send(Object) as "json"', function(){
     });
   });
 
-  if (doesntWorkInBrowserYet) it('should work with GET', done => {
+  if (doesntWorkInBrowserYet && doesntWorkInHttp2) it('should work with GET', done => {
     request
     .get(`${uri}/echo`)
     .send({ tobi: 'ferret' })

test/node/agency.js

@@ -9,6 +9,10 @@ const assert = require("assert");
 const should = require("should");
 const cookieParser = require("cookie-parser");
 const session = require("express-session");
+let http = require('http');
+if(process.env.EXPOSE_HTTP2){
+  http = require('http2');
+}
 
 app.use(cookieParser());
 app.use(
@@ -60,7 +64,8 @@ app.get("/simple", (req, res) => {
 let base = "http://localhost";
 let server;
 before(function listen(done) {
-  server = app.listen(0, function listening() {
+  server = http.createServer(app);
+  server = server.listen(0, function listening() {
     base += `:${server.address().port}`;
     done();
   });

test/node/basic.js

@@ -8,6 +8,7 @@ const fs = require("fs");
 const EventEmitter = require("events").EventEmitter;
 const StringDecoder = require("string_decoder").StringDecoder;
 const url = require("url");
+const doesntWorkInHttp2 = !process.env.EXPOSE_HTTP2;
 
 describe("[node] request", () => {
   describe("with an url", () => {
@@ -299,7 +300,7 @@ describe("[node] request", () => {
     });
   });
 
-  it("should send body with .get().send()", next => {
+  if(doesntWorkInHttp2) it("should send body with .get().send()", next => {
     request
       .get(`${base}/echo`)
       .set("Content-Type", "text/plain")