Http2ServerResponse.createPushRequest

Author: sebdeckers

lib/internal/http2/compat.js

@@ -362,7 +362,7 @@ class Http2ServerResponse extends Stream {
   setHeader(name, value) {
     var state = this[kState];
     if (state.headersSent)
-      throw new Error('Cannot set status after the HTTP message has been sent');
+      throw new Error('Cannot set headers after the HTTP message has been sent');
     name = String(name).trim().toLowerCase();
     assertValidHeader(name, value);
     var headers = this[kHeaders];
@@ -452,13 +452,13 @@ class Http2ServerResponse extends Stream {
     stream.respond(headers);
   }
 
-  createPushResponse(headers, options, callback) {
+  createPushRequest(headers) {
     var stream = this[kStream];
     if (!stream) {
-      callback(new Error('HTTP/2 Stream has been closed'));
-      return;
+      throw new Error('HTTP/2 Stream has been closed');
     }
-    return stream.pushStream(headers, options, callback);
+    var request = new Http2PushRequest(stream, headers);
+    return request;
   }
 
   [kBeginSend]() {
@@ -519,4 +519,41 @@ function onServerStream(stream, headers, flags) {
   server.emit('request', request, response);
 }
 
+class Http2PushRequest {
+  constructor(stream, headers) {
+    this[kStream] = stream;
+    this[kHeaders] = headers || Object.create(null);
+    this[kState] = {
+      headersSent: false
+    };
+  }
+
+  push(callback) {
+    var state = this[kState];
+    if (state.headersSent)
+      throw new Error('Cannot push request headers ' +
+        'after the HTTP message has been sent');
+    var stream = this[kStream];
+    if (!stream)
+      throw new Error('HTTP/2 Stream has been closed');
+    var headers = this[kHeaders];
+    try {
+      stream.pushStream(
+        headers,
+        function(error, promisedStream, headers, options) {
+          if (error) {
+            callback(error);
+            return;
+          }
+          var response = new Http2ServerResponse(promisedStream);
+          callback(null, response);
+        }
+      );
+      state.headersSent = true;
+    } catch (error) {
+      callback(error);
+    }
+  }
+}
+
 module.exports = { onServerStream };

test/parallel/test-http2-compat-Http2ServerResponse-createPushRequest.js

@@ -0,0 +1,105 @@
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+const h2 = require('http2');
+const net = require('net');
+
+function isEven(number) {
+  return number % 2 === 0;
+}
+
+function isOdd(number) {
+  return number % 2 === 1;
+}
+
+// Push a request & response
+function requestListener(request, response) {
+  return new Promise(function(resolve) {
+    assert.ok(isOdd(response.stream.id));
+    const headers = {
+      ':path': '/pushed',
+      ':method': 'GET',
+      ':scheme': 'http',
+      ':authority': 'localhost'
+    };
+    const pushRequest = response.createPushRequest(headers);
+    pushRequest.push(common.mustCall(function(error, pushResponse) {
+      assert.strictEqual(error, null);
+      assert.ok(isEven(pushResponse.stream.id));
+      pushResponse.end('This is a server-initiated response');
+      response.end('This is a client-initiated response');
+      resolve();
+    }));
+  });
+}
+
+function clientRequest(client, socket) {
+  const headers = {
+    ':path': '/',
+    ':method': 'GET',
+    ':scheme': 'http',
+    ':authority': 'localhost'
+  };
+  return new Promise(function(resolve) {
+    const requestStream = client.request(headers);
+
+    // TODO seb: fix the missing promised stream id for the pushed stream
+    // The PUSH_PROMISE frame is received in onHeaders.
+    // Because the event payload lacks a Promised Stream ID the headers
+    // are triggered as an event on the parent stream,
+    // causing this test to fail.
+
+    function onStream(pushStream, headers, flags) {
+      assert.strictEqual(headers[':status'], '200');
+      assert.strictEqual(headers[':path'], '/pushed');
+      assert.strictEqual(headers[':method'], 'GET');
+      assert.strictEqual(headers[':scheme'], 'http');
+      assert.strictEqual(headers[':authority'], 'localhost');
+      assert.ok(headers['date']);
+      assert.strictEqual(flags, h2.constants.NGHTTP2_FLAG_END_HEADERS);
+
+      pushStream.on('data', common.mustCall(function(data) {
+        assert.strictEqual(data.toString(),
+          'This is a server-initiated response');
+      }));
+
+      pushStream.on('streamClosed', resolve);
+    }
+    requestStream.session.on('stream', common.mustCall(onStream));
+
+    requestStream.on('response', common.mustCall(function(headers, flags) {
+      assert.strictEqual(headers[':status'], '200');
+      assert.strictEqual(headers[':path'], '/');
+      assert.strictEqual(headers[':method'], 'GET');
+      assert.strictEqual(headers[':scheme'], 'http');
+      assert.strictEqual(headers[':authority'], 'localhost');
+      assert.ok(headers['date']);
+      assert.strictEqual(flags, h2.constants.NGHTTP2_FLAG_END_HEADERS);
+    }));
+
+    requestStream.on('data', common.mustCall(function(data) {
+      assert.strictEqual(data.toString(),
+        'This is a client-initiated response');
+    }));
+  });
+}
+
+let socket;
+const stages = [];
+const server = h2.createServer();
+server.listen(0, common.mustCall(function() {
+  console.log(server.address());
+  server.once('request', common.mustCall(function(request, response) {
+    stages.push(requestListener(request, response));
+    Promise.all(stages)
+      .then(function() {
+        socket.destroy();
+        server.close();
+      });
+  }));
+  socket = net.connect(server.address(), common.mustCall(function() {
+    const client = h2.createClientSession(socket);
+    stages.push(clientRequest(client, socket));
+  }));
+}));

test/parallel/test-http2-compat-Http2ServerResponse-createPushResponse.js

@@ -12,9 +12,6 @@ function requestListener(request, response) {
   response.setHeader('foo-bar', 'def456');
   response.writeHead(statusCode, headers);
   response.writeHead(statusCode, headers); // Idempotent
-
-  response.writeHead = common.mustCall(function mock() {});
-  response.writeHeader(statusCode, headers);
 }
 
 function clientRequest(client, socket) {