http: allow to close connections on server.close

Author: ShogunPanda

doc/api/http.md

@@ -1443,16 +1443,31 @@ This event is guaranteed to be passed an instance of the {net.Socket} class,
 a subclass of {stream.Duplex}, unless the user specifies a socket
 type other than {net.Socket}.
 
-### `server.close([callback])`
+### `server.close([options][, callback])`
 
 <!-- YAML
 added: v0.1.90
+changes:
+  - version: REPLACEME
+    pr-url: https://github.com/nodejs/node/pull/42811
+    description: The `options` argument is now supported.
 -->
 
+* `options` {Object}
+  * `force` {string} Specified which kind of already opened connections to
+    forcefully close. Supported values are:
+    * `keep-alive`: Will close all idle connections (which are using
+      HTTP Keep-Alive).
+    * `all`: Will close all currently opened connections without completing
+      any request.
 * `callback` {Function}
 
 Stops the server from accepting new connections. See [`net.Server.close()`][].
 
+If no `options.force` is specified (the default), the server will not accept
+new connections but will complete pending requests and it will serve new
+requests received through already opened connections using HTTP Keep-Alive.
+
 ### `server.headersTimeout`
 
 <!-- YAML

lib/_http_server.js

@@ -453,9 +453,36 @@ function Server(options, requestListener) {
 ObjectSetPrototypeOf(Server.prototype, net.Server.prototype);
 ObjectSetPrototypeOf(Server, net.Server);
 
-Server.prototype.close = function() {
+Server.prototype.close = function(args, callback) {
   clearInterval(this[kConnectionsCheckingInterval]);
-  ReflectApply(net.Server.prototype.close, this, arguments);
+
+  if (typeof args === 'function') {
+    callback = args
+    args = {}
+  }
+
+  ReflectApply(net.Server.prototype.close, this, [callback]);
+
+  if (typeof args === 'object' && 'force' in args) {
+    let toClose = []
+    
+    switch (args.force) {
+      case 'keep-alive':
+        toClose = this[kConnections].idle();
+        break;
+      case 'all':
+        toClose = this[kConnections].all();
+        break;
+    }
+
+    for (let i = 0, length = toClose.length; i < length; i++) {
+      const socket = toClose[i].socket;
+
+      if (socket) {
+        socket.destroy();
+      }
+    }
+  }
 };
 
 Server.prototype.setTimeout = function setTimeout(msecs, callback) {

test/parallel/test-http-server-close-all.js

@@ -0,0 +1,47 @@
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+
+const { createServer } = require('http');
+const { connect } = require('net');
+
+const server = createServer(common.mustCall(function(req, res) {
+  res.writeHead(200, { 'Connection': 'keep-alive' });
+  res.end();
+}), { requestTimeout: 60000, headersTimeout: 0 });
+
+
+server.listen(0, function() {
+  const port = server.address().port;
+
+  // Create a new request, let it finish but leave the connection opened using HTTP keep-alive
+  const client1 = connect(port);
+  let response1 = '';
+
+  client1.on('data', common.mustCall((chunk) => {
+    response1 += chunk.toString('utf-8');
+  }));
+
+  client1.on('end', common.mustCall(function() {
+    assert(response1.startsWith('HTTP/1.1 200 OK\r\nConnection: keep-alive'));
+  }));
+  client1.on('close', common.mustCall());
+
+  client1.resume();
+  client1.write('GET / HTTP/1.1\r\nConnection: keep-alive\r\n\r\n');
+
+  // Create a second request but never finish it
+  const client2 = connect(port);
+  client2.on('close', common.mustCall());
+
+  client2.resume();
+  client2.write('GET / HTTP/1.1\r\n');
+
+  // Now, after a while, close the server
+  setTimeout(() => {
+    server.close({ force: 'all' }, common.mustCall());
+  }, common.platformTimeout(1000));
+
+  // This timer should never go off as the server.close should shut everything down
+  setTimeout(common.mustNotCall(), common.platformTimeout(1500)).unref();
+});

test/parallel/test-http-server-close-idle.js

@@ -0,0 +1,57 @@
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+
+const { createServer } = require('http');
+const { connect } = require('net');
+
+const server = createServer(common.mustCall(function(req, res) {
+  res.writeHead(200, { 'Connection': 'keep-alive' });
+  res.end();
+}), { requestTimeout: 60000, headersTimeout: 0 });
+
+
+server.listen(0, function() {
+  const port = server.address().port;
+
+  // Create a new request, let it finish but leave the connection opened using HTTP keep-alive
+  const client1 = connect(port);
+  let response1 = '';
+  let client1Closed = false;
+
+  client1.on('data', common.mustCall((chunk) => {
+    response1 += chunk.toString('utf-8');
+  }));
+
+  client1.on('end', common.mustCall(function() {
+    assert(response1.startsWith('HTTP/1.1 200 OK\r\nConnection: keep-alive'));
+  }));
+  client1.on('close', common.mustCall(() => {
+    client1Closed = true;
+  }));
+
+  client1.resume();
+  client1.write('GET / HTTP/1.1\r\nConnection: keep-alive\r\n\r\n');
+
+  // Create a second request but never finish it
+  const client2 = connect(port);
+  let client2Closed = false;
+  client2.on('close', common.mustCall(() => {
+    client2Closed = true;
+  }));
+
+  client2.resume();
+  client2.write('GET / HTTP/1.1\r\n');
+
+  // Now, after a while, close the server
+  setTimeout(() => {
+    server.close({ force: 'keep-alive' }, common.mustCall());
+  }, common.platformTimeout(1000));
+
+  // Check that only the idle connection got closed
+  setTimeout(common.mustCall(() => {
+    assert(client1Closed);
+    assert(!client2Closed);
+    server.close({ force: 'all' });
+  }), common.platformTimeout(1500)).unref();
+});

test/parallel/test-http-server-request-timeout-keepalive.js

@@ -28,11 +28,12 @@ function performRequestWithDelay(client, firstDelay, secondDelay, closeAfter) {
 }
 
 const requestTimeout = common.platformTimeout(1000);
+const connectionsCheckingInterval = common.platformTimeout(250)
 const server = createServer({
   headersTimeout: 0,
   requestTimeout,
   keepAliveTimeout: 0,
-  connectionsCheckingInterval: common.platformTimeout(250),
+  connectionsCheckingInterval,
 }, common.mustCallAtLeast((req, res) => {
   res.writeHead(200, { 'Content-Type': 'text/plain' });
   res.end();
@@ -70,7 +71,7 @@ server.listen(0, common.mustCall(() => {
         performRequestWithDelay(
           client,
           requestTimeout / 5,
-          requestTimeout,
+          requestTimeout * 2,
           true
         );
       }, defer).unref();
@@ -91,7 +92,7 @@ server.listen(0, common.mustCall(() => {
   client.on('error', errOrEnd);
   client.on('end', errOrEnd);
 
-  // Perform a second request expected to finish before requestTimeout
+  // Perform a first request which is completed immediately
   performRequestWithDelay(
     client,
     requestTimeout / 5,

test/parallel/test-http-server-request-timeout-pipelining.js

@@ -66,5 +66,5 @@ server.listen(0, common.mustCall(() => {
   // Complete the request
   setTimeout(() => {
     client.write('close\r\n\r\n');
-  }, requestTimeout * 1.5).unref();
+  }, requestTimeout * 2).unref();
 }));

test/parallel/test-http-server-request-timeout-upgrade.js

@@ -58,6 +58,6 @@ server.listen(0, common.mustCall(() => {
     setTimeout(() => {
       client.write('12345678901234567890');
       client.end();
-    }, common.platformTimeout(2000)).unref();
+    }, common.platformTimeout(requestTimeout * 2)).unref();
   });
 }));

test/parallel/test-http-server-request-timeouts-mixed.js

@@ -0,0 +1,133 @@
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+const { createServer } = require('http');
+const { connect } = require('net');
+
+// This test validates that request are correct checked for both requests and headers timeout in various situations.
+
+const requestBodyPart1 = 'POST / HTTP/1.1\r\nContent-Length: 20\r\n';
+const requestBodyPart2 = 'Connection: close\r\n\r\n1234567890';
+const requestBodyPart3 = '1234567890';
+
+const responseOk = 'HTTP/1.1 200 OK\r\n';
+const responseTimeout = 'HTTP/1.1 408 Request Timeout\r\n';
+
+const headersTimeout = common.platformTimeout(2000);
+const connectionsCheckingInterval = common.platformTimeout(500);
+
+const server = createServer({
+  headersTimeout,
+  requestTimeout: headersTimeout * 2,
+  keepAliveTimeout: 0,
+  connectionsCheckingInterval,
+}, common.mustCall((req, res) => {
+  req.on('data', () => {
+    // No-op
+  });
+
+  req.on('end', () => {
+    res.writeHead(200, { 'Content-Type': 'text/plain' });
+    res.end();
+  });
+}, 4));
+
+assert.strictEqual(server.headersTimeout, headersTimeout);
+assert.strictEqual(server.requestTimeout, headersTimeout * 2);
+
+let i = 0;
+function createClient(server) {
+  const request = {
+    index: i++,
+    client: connect(server.address().port),
+    response: '',
+    completed: false
+  };
+
+  request.client.on('data', common.mustCallAtLeast((chunk) => {
+    request.response += chunk.toString('utf-8');
+  }));
+
+  request.client.on('end', common.mustCall(() => {
+    request.completed = true;
+  }));
+
+  request.client.on('error', common.mustNotCall());
+
+  request.client.resume();
+
+  return request;
+}
+
+server.listen(0, common.mustCall(() => {
+  const request1 = createClient(server);
+  let request2;
+  let request3;
+  let request4;
+  let request5;
+
+  // Send the first request and stop before the body
+  request1.client.write(requestBodyPart1);
+
+  // After a little while send two new requests
+  setTimeout(() => {
+    request2 = createClient(server);
+    request3 = createClient(server);
+
+    // Send the second request, stop in the middle of the headers
+    request2.client.write(requestBodyPart1);
+    // Send the second request, stop in the middle of the headers
+    request3.client.write(requestBodyPart1);
+  }, headersTimeout * 0.2);
+
+  // After another little while send the last two new requests
+  setTimeout(() => {
+    request4 = createClient(server);
+    request5 = createClient(server);
+
+    // Send the fourth request, stop in the middle of the headers
+    request4.client.write(requestBodyPart1);
+    // Send the fifth request, stop in the middle of the headers
+    request5.client.write(requestBodyPart1);
+  }, headersTimeout * 0.6);
+
+  setTimeout(() => {
+    // Finish the first request
+    request1.client.write(requestBodyPart2 + requestBodyPart3);
+
+    // Complete headers for all requests but second
+    request3.client.write(requestBodyPart2);
+    request4.client.write(requestBodyPart2);
+    request5.client.write(requestBodyPart2);
+  }, headersTimeout * 0.8);
+
+  setTimeout(() => {
+    // After the first timeout, the first request should have been completed and second timedout
+    assert(request1.completed);
+    assert(request2.completed);
+    assert(!request3.completed);
+    assert(!request4.completed);
+    assert(!request5.completed);
+
+    assert(request1.response.startsWith(responseOk));
+    assert(request2.response.startsWith(responseTimeout)); // It is expired due to headersTimeout
+  }, headersTimeout * 1.2 + connectionsCheckingInterval);
+
+  setTimeout(() => {
+    // Complete the body for the fourth request
+    request4.client.write(requestBodyPart3);
+  }, headersTimeout * 1.5);
+
+  setTimeout(() => {
+    // All request should be completed now, either with 200 or 408
+    assert(request3.completed);
+    assert(request4.completed);
+    assert(request5.completed);
+
+    assert(request3.response.startsWith(responseTimeout)); // It is expired due to requestTimeout
+    assert(request4.response.startsWith(responseOk));
+    assert(request5.response.startsWith(responseTimeout)); // It is expired due to requestTimeout
+    server.close();
+  }, headersTimeout * 3 + connectionsCheckingInterval);
+}));