From e4ea0314782263ae2cc19bb0a7c2df62b47c7128 Mon Sep 17 00:00:00 2001
From: Robert Nagy <ronagy@icloud.com>
Date: Wed, 10 Jul 2019 13:12:37 +0200
Subject: [PATCH] http: added closed property

---
 doc/api/http.md                               | 18 ++++++++++++++++++
 lib/_http_client.js                           | 17 +++++++++++------
 lib/_http_incoming.js                         |  1 +
 lib/_http_outgoing.js                         |  1 +
 lib/_http_server.js                           | 14 +++++++++++---
 lib/internal/http2/compat.js                  |  8 ++++++++
 test/parallel/test-http-client-close-event.js |  1 +
 test/parallel/test-http-connect-req-res.js    | 17 ++++++++++++++++-
 test/parallel/test-http-req-res-close.js      |  7 +++----
 test/parallel/test-http-response-close.js     |  2 ++
 10 files changed, 72 insertions(+), 14 deletions(-)

diff --git a/doc/api/http.md b/doc/api/http.md
index 0588d7f408f194..0f095f579e341e 100644
--- a/doc/api/http.md
+++ b/doc/api/http.md
@@ -553,6 +553,15 @@ changes:
 The `request.aborted` property will be `true` if the request has
 been aborted.
 
+### request.closed
+<!-- YAML
+added: CHANGEME
+-->
+
+* {boolean}
+
+The `request.closed` property indicates whether the request has been closed.
+
 ### request.connection
 <!-- YAML
 added: v0.3.0
@@ -1130,6 +1139,15 @@ response.end();
 Attempting to set a header field name or value that contains invalid characters
 will result in a [`TypeError`][] being thrown.
 
+### response.closed
+<!-- YAML
+added: CHANGEME
+-->
+
+* {boolean}
+
+The `response.closed` property indicates whether the response has been closed.
+
 ### response.connection
 <!-- YAML
 added: v0.3.0
diff --git a/lib/_http_client.js b/lib/_http_client.js
index 4af23fa8c574f0..187def09afc942 100644
--- a/lib/_http_client.js
+++ b/lib/_http_client.js
@@ -191,6 +191,7 @@ function ClientRequest(input, options, cb) {
   this._ended = false;
   this.res = null;
   this.aborted = false;
+  this.closed = false;
   this.timeoutCb = null;
   this.upgradeOrConnect = false;
   this.parser = null;
@@ -358,14 +359,12 @@ function socketCloseListener() {
       res.aborted = true;
       res.emit('aborted');
     }
-    req.emit('close');
+    emitClose.call(req);
     if (res.readable) {
-      res.on('end', function() {
-        this.emit('close');
-      });
+      res.on('end', emitClose);
       res.push(null);
     } else {
-      res.emit('close');
+      emitClose.call(res);
     }
   } else {
     if (!req.socket._hadError) {
@@ -375,7 +374,7 @@ function socketCloseListener() {
       req.socket._hadError = true;
       req.emit('error', connResetException('socket hang up'));
     }
-    req.emit('close');
+    emitClose.call(req);
   }
 
   // Too bad.  That output wasn't getting written.
@@ -417,6 +416,11 @@ function socketErrorListener(err) {
   socket.destroy();
 }
 
+function emitClose() {
+  this.closed = true;
+  this.emit('close');
+}
+
 function freeSocketErrorListener(err) {
   const socket = this;
   debug('SOCKET ERROR on FREE socket:', err.message, err.stack);
@@ -487,6 +491,7 @@ function socketOnData(d) {
       socket.readableFlowing = null;
 
       req.emit(eventName, res, socket, bodyHead);
+      req.closed = true;
       req.emit('close');
     } else {
       // Requested Upgrade or used CONNECT method, but have no handler.
diff --git a/lib/_http_incoming.js b/lib/_http_incoming.js
index 3ec23616b15b02..8f7e0b0fcd1dc7 100644
--- a/lib/_http_incoming.js
+++ b/lib/_http_incoming.js
@@ -56,6 +56,7 @@ function IncomingMessage(socket) {
   this.readable = true;
 
   this.aborted = false;
+  this.closed = false;
 
   this.upgrade = null;
 
diff --git a/lib/_http_outgoing.js b/lib/_http_outgoing.js
index a4a2b3ab144400..08b87ac5a31fae 100644
--- a/lib/_http_outgoing.js
+++ b/lib/_http_outgoing.js
@@ -96,6 +96,7 @@ function OutgoingMessage() {
   this._trailer = '';
 
   this.finished = false;
+  this.closed = false;
   this._headerSent = false;
   this[kIsCorked] = false;
 
diff --git a/lib/_http_server.js b/lib/_http_server.js
index f82685e2be4bcd..fbe2d691440c10 100644
--- a/lib/_http_server.js
+++ b/lib/_http_server.js
@@ -178,7 +178,9 @@ function onServerResponseClose() {
   // Ergo, we need to deal with stale 'close' events and handle the case
   // where the ServerResponse object has already been deconstructed.
   // Fortunately, that requires only a single if check. :-)
-  if (this._httpMessage) this._httpMessage.emit('close');
+  if (this._httpMessage) {
+    emitClose.call(this._httpMessage);
+  }
 }
 
 ServerResponse.prototype.assignSocket = function assignSocket(socket) {
@@ -469,7 +471,7 @@ function abortIncoming(incoming) {
     var req = incoming.shift();
     req.aborted = true;
     req.emit('aborted');
-    req.emit('close');
+    emitClose.call(req);
   }
   // Abort socket._httpMessage ?
 }
@@ -594,6 +596,11 @@ function onParserExecuteCommon(server, socket, parser, state, ret, d) {
   }
 }
 
+function emitClose() {
+  this.closed = true;
+  this.emit('close');
+}
+
 function resOnFinish(req, res, socket, state, server) {
   // Usually the first incoming element should be our request.  it may
   // be that in the case abortIncoming() was called that the incoming
@@ -609,7 +616,8 @@ function resOnFinish(req, res, socket, state, server) {
     req._dump();
 
   res.detachSocket(socket);
-  req.emit('close');
+  res.closed = true;
+  emitClose.call(req);
   process.nextTick(emitCloseNT, res);
 
   if (res._last) {
diff --git a/lib/internal/http2/compat.js b/lib/internal/http2/compat.js
index 516954587108a8..e2438490d47c55 100644
--- a/lib/internal/http2/compat.js
+++ b/lib/internal/http2/compat.js
@@ -297,6 +297,10 @@ class Http2ServerRequest extends Readable {
     this.on('resume', onRequestResume);
   }
 
+  get closed() {
+    return this[kState].closed;
+  }
+
   get aborted() {
     return this[kAborted];
   }
@@ -446,6 +450,10 @@ class Http2ServerResponse extends Stream {
     stream.on('timeout', onStreamTimeout(kResponse));
   }
 
+  get closed() {
+    return this[kState].closed;
+  }
+
   // User land modules such as finalhandler just check truthiness of this
   // but if someone is actually trying to use this for more than that
   // then we simply can't support such use cases
diff --git a/test/parallel/test-http-client-close-event.js b/test/parallel/test-http-client-close-event.js
index 7573931ac48ef6..f533587c375396 100644
--- a/test/parallel/test-http-client-close-event.js
+++ b/test/parallel/test-http-client-close-event.js
@@ -23,6 +23,7 @@ server.listen(0, common.mustCall(() => {
 
   req.on('close', common.mustCall(() => {
     assert.strictEqual(errorEmitted, true);
+    assert.strictEqual(req.closed, true);
     server.close();
   }));
 
diff --git a/test/parallel/test-http-connect-req-res.js b/test/parallel/test-http-connect-req-res.js
index 893c621852be89..e9656f9fff26d1 100644
--- a/test/parallel/test-http-connect-req-res.js
+++ b/test/parallel/test-http-connect-req-res.js
@@ -33,9 +33,14 @@ server.listen(0, common.mustCall(function() {
     path: 'example.com:443'
   }, common.mustNotCall());
 
-  req.on('close', common.mustCall());
+  assert.strictEqual(req.closed, false);
+  req.on('close', common.mustCall(() => {
+    assert.strictEqual(req.closed, true);
+  }));
 
   req.on('connect', common.mustCall(function(res, socket, firstBodyChunk) {
+    assert.strictEqual(req.closed, false);
+
     console.error('Client got CONNECT request');
 
     // Make sure this request got removed from the pool.
@@ -54,10 +59,20 @@ server.listen(0, common.mustCall(function() {
     // Test that the firstBodyChunk was not parsed as HTTP
     assert.strictEqual(data, 'Head');
 
+    let closeEmitted = false;
+
+    req.on('close', common.mustCall(() => {
+      closeEmitted = true;
+    }));
+
     socket.on('data', function(buf) {
+      assert.strictEqual(req.closed, true); // TODO: This should be false
+      assert.strictEqual(closeEmitted, true); // TODO: This should be false
       data += buf.toString();
     });
     socket.on('end', function() {
+      assert.strictEqual(req.closed, true); // TODO: This should be false
+      assert.strictEqual(closeEmitted, true); // TODO: This should be false
       assert.strictEqual(data, 'HeadRequestEnd');
       server.close();
     });
diff --git a/test/parallel/test-http-req-res-close.js b/test/parallel/test-http-req-res-close.js
index daba55f43427c2..7f2353bb8f6eb0 100644
--- a/test/parallel/test-http-req-res-close.js
+++ b/test/parallel/test-http-req-res-close.js
@@ -5,16 +5,15 @@ const http = require('http');
 const assert = require('assert');
 
 const server = http.Server(common.mustCall((req, res) => {
-  let resClosed = false;
-
   res.end();
   res.on('finish', common.mustCall(() => {
-    assert.strictEqual(resClosed, false);
+    assert.strictEqual(res.closed, false);
   }));
   res.on('close', common.mustCall(() => {
-    resClosed = true;
+    assert.strictEqual(res.closed, true);
   }));
   req.on('close', common.mustCall(() => {
+    assert.strictEqual(req.closed, true);
     assert.strictEqual(req._readableState.ended, true);
   }));
   res.socket.on('close', () => server.close());
diff --git a/test/parallel/test-http-response-close.js b/test/parallel/test-http-response-close.js
index 4c36003357980b..f9db64cf52a5ac 100644
--- a/test/parallel/test-http-response-close.js
+++ b/test/parallel/test-http-response-close.js
@@ -22,6 +22,7 @@
 'use strict';
 const common = require('../common');
 const http = require('http');
+const assert = require('assert');
 
 {
   const server = http.createServer(
@@ -40,6 +41,7 @@ const http = require('http');
             res.destroy();
           }));
           res.on('close', common.mustCall(() => {
+            assert.strictEqual(res.closed, true);
             server.close();
           }));
         })