69

I have a Node.js application that contains an http(s) server.

In a specific case, I need to shutdown this server programmatically. What I am currently doing is calling its close() function, but this does not help, as it waits for any kept alive connections to finish first.

So, basically, this shutdowns the server, but only after a minimum wait time of 120 seconds. But I want the server to shutdown immediately - even if this means breaking up with currently handled requests.

What I can not do is a simple

process.exit();

as the server is only part of the application, and the rest of the application should remain running. What I am looking for is conceptually something such as server.destroy(); or something like that.

How could I achieve this?

PS: The keep-alive timeout for connections is usually required, hence it is not a viable option to decrease this time.

Golo Roden
  • 140,679
  • 96
  • 298
  • 425

11 Answers11

82

The trick is that you need to subscribe to the server's connection event which gives you the socket of the new connection. You need to remember this socket and later on, directly after having called server.close(), destroy that socket using socket.destroy().

Additionally, you need to listen to the socket's close event to remove it from the array if it leaves naturally because its keep-alive timeout does run out.

I have written a small sample application you can use to demonstrate this behavior:

// Create a new server on port 4000
var http = require('http');
var server = http.createServer(function (req, res) {
  res.end('Hello world!');
}).listen(4000);

// Maintain a hash of all connected sockets
var sockets = {}, nextSocketId = 0;
server.on('connection', function (socket) {
  // Add a newly connected socket
  var socketId = nextSocketId++;
  sockets[socketId] = socket;
  console.log('socket', socketId, 'opened');

  // Remove the socket when it closes
  socket.on('close', function () {
    console.log('socket', socketId, 'closed');
    delete sockets[socketId];
  });

  // Extend socket lifetime for demo purposes
  socket.setTimeout(4000);
});

// Count down from 10 seconds
(function countDown (counter) {
  console.log(counter);
  if (counter > 0)
    return setTimeout(countDown, 1000, counter - 1);

  // Close the server
  server.close(function () { console.log('Server closed!'); });
  // Destroy all open sockets
  for (var socketId in sockets) {
    console.log('socket', socketId, 'destroyed');
    sockets[socketId].destroy();
  }
})(10);

Basically, what it does is to start a new HTTP server, count from 10 to 0, and close the server after 10 seconds. If no connection has been established, the server shuts down immediately.

If a connection has been established and it is still open, it is destroyed. If it had already died naturally, only a message is printed out at that point in time.

Lior Cohen
  • 8,985
  • 2
  • 29
  • 27
Golo Roden
  • 140,679
  • 96
  • 298
  • 425
  • 2
    Should `socket.on("close",...)` be `socket.once("close",...)`? – jpillora Mar 01 '14 at 03:37
  • 1
    Or, as mentioned in a comment below, use https://github.com/hunterloftis/stoppable - it is likely to work better than the code above and will save you ink! – Izhaki Sep 11 '18 at 22:21
  • 1
    The answer could be updated: `sockets` variable could use `Set` like `const sockets = new Set(); sockets.add(socket); sockets.forEach((socket) => socket.destroy());`. – Alexander Shutau Nov 28 '18 at 21:57
  • 1
    If only I could give you a million upvotes. A little Express.js test thingy I've written was being really slow when it was loading pages that included external JavaScript and parsing them with JSDOM. I think JSDOM was [doing some keep-alive shenanigans](https://github.com/jsdom/jsdom/issues/2176). But destroying the sockets as you suggested sorts it right out. – Paul D. Waite Nov 09 '19 at 00:55
23

I found a way to do this without having to keep track of the connections or having to force them closed. I'm not sure how reliable it is across Node versions or if there are any negative consequences to this but it seems to work perfectly fine for what I'm doing. The trick is to emit the "close" event using setImmediate right after calling the close method. This works like so:

server.close(callback);
setImmediate(function(){server.emit('close')});

At least for me, this ends up freeing the port so that I can start a new HTTP(S) service by the time the callback is called (which is pretty much instantly). Existing connections stay open. I'm using this to automatically restart the HTTPS service after renewing a Let's Encrypt certificate.

Jonathan Gray
  • 2,509
  • 15
  • 20
  • Based on your answer, I use `server.close(); setImmediate(callback);`. – adabru Aug 19 '18 at 22:45
  • Can you elaborate on what you're doing here, and why it works? It seems to me that calling `server.close()` and opening a new one in the callback will allow you to retain existing connections while listening for new. Your code example seems sketchy... you shouldn't have to emit events on the server like this, so I'm curious how you came to this conclusion. – Brad Nov 14 '18 at 21:59
  • @Brad I've been upfront about the sketchiness of using this. It was simply an idea that I had at the time in an attempt to solve the issue that the callback wouldn't be called until all of the connections were closed (as evidenced by the question and other answers). Sure, I could have just gone the route of using setImmediate's callback directly as the comment above yours suggests, however that doesn't guarantee that no issues would be caused as some important cleanup actions might be dependent on the close event. Therefore I decided that just emitting the event isn't such a bad idea. – Jonathan Gray Nov 22 '18 at 18:34
  • Excellent it works, and doesn't require tracking connections and having to make sure performance in production isn't affected. – MyUserInStackOverflow Feb 06 '20 at 17:41
14

If you need to keep the process alive after closing the server, then Golo Roden's solution is probably the best.

But if you're closing the server as part of a graceful shutdown of the process, you just need this:

var server = require('http').createServer(myFancyServerLogic);

server.on('connection', function (socket) {socket.unref();});
server.listen(80);

function myFancyServerLogic(req, res) {
    req.connection.ref();

    res.end('Hello World!', function () {
        req.connection.unref();
    });
}

Basically, the sockets that your server uses will only keep the process alive while they're actually serving a request. While they're just sitting there idly (because of a Keep-Alive connection), a call to server.close() will close the process, as long as there's nothing else keeping the process alive. If you need to do other things after the server closes, as part of your graceful shutdown, you can hook into process.on('beforeExit', callback) to finish your graceful shutdown procedures.

Joshua Wise
  • 613
  • 4
  • 15
9

The https://github.com/isaacs/server-destroy library provides an easy way to destroy() a server with the behavior desired in the question (by tracking opened connections and destroying each of them on server destroy, as described in other answers).

ploer
  • 426
  • 4
  • 4
  • 2
    A maintained alternative, https://github.com/thedillonb/http-shutdown and https://github.com/hunterloftis/stoppable. – Gajus Nov 22 '17 at 06:36
  • 2
    I have since developed https://github.com/gajus/http-terminator. Unlike other libraries, `http-terminator` does not monkey-patch HTTP server instance. – Gajus Jan 19 '20 at 23:40
6

As others have said, the solution is to keep track of all open sockets and close them manually. My node package killable can do this for you. An example (using express, but you can call use killable on any http.server instance):

var killable = require('killable');

var app = require('express')();
var server;

app.route('/', function (req, res, next) {
  res.send('Server is going down NOW!');

  server.kill(function () {
    //the server is down when this is called. That won't take long.
  });
});

var server = app.listen(8080);
killable(server);
marten-de-vries
  • 236
  • 2
  • 4
3

Yet another nodejs package to perform a shutdown killing connections: http-shutdown, which seems reasonably maintained at the time of writing (Sept. 2016) and worked for me on NodeJS 6.x

From the documentation

Usage

There are currently two ways to use this library. The first is explicit wrapping of the Server object:

// Create the http server
var server = require('http').createServer(function(req, res) {
  res.end('Good job!');
});

// Wrap the server object with additional functionality.
// This should be done immediately after server construction, or before you start listening.
// Additional functionailiy needs to be added for http server events to properly shutdown.
server = require('http-shutdown')(server);

// Listen on a port and start taking requests.
server.listen(3000);

// Sometime later... shutdown the server.
server.shutdown(function() {
  console.log('Everything is cleanly shutdown.');
});

The second is implicitly adding prototype functionality to the Server object:

// .extend adds a .withShutdown prototype method to the Server object
require('http-shutdown').extend();

var server = require('http').createServer(function(req, res) {
  res.end('God job!');
}).withShutdown(); // <-- Easy to chain. Returns the Server object

// Sometime later, shutdown the server.
server.shutdown(function() {
  console.log('Everything is cleanly shutdown.');
});
Bruno Grieder
  • 28,128
  • 8
  • 69
  • 101
2

My best guess would be to kill the connections manually (i.e. to forcibly close it's sockets).

Ideally, this should be done by digging into the server's internals and closing it's sockets by hand. Alternatively, one could run a shell-command that does the same (provided the server has proper privileges &c.)

Morten Siebuhr
  • 6,068
  • 4
  • 31
  • 43
  • 1
    The question is: How do I access the connections' sockets without using any undocumented behavior? – Golo Roden Jan 31 '13 at 18:12
  • Basically, your answer helped me get on the right track. See my answer on how I solved it (without using any undocumented behavior ;-)). Anyway, +1 for the right idea :-) – Golo Roden Jan 31 '13 at 22:55
  • That's why I was being vague. It depends rather lot what (if any) wrapper libraries you use (`Express`, for example) and what version of Node.js/libraries you're using (API's vary over time) – Morten Siebuhr Feb 01 '13 at 11:31
2

I have answered a variation of "how to terminate a HTTP server" many times on different support channels. Unfortunately, I couldn't recommend any of the existing libraries because they are lacking in one or another way. I have since put together a package that (I believe) is handling all the cases expected of graceful HTTP server termination.

https://github.com/gajus/http-terminator

The main benefit of http-terminator is that:

  • it does not monkey-patch Node.js API
  • it immediately destroys all sockets without an attached HTTP request
  • it allows graceful timeout to sockets with ongoing HTTP requests
  • it properly handles HTTPS connections
  • it informs connections using keep-alive that server is shutting down by setting a connection: close header
  • it does not terminate the Node.js process

Usage:

import http from 'http';
import {
  createHttpTerminator,
} from 'http-terminator';

const server = http.createServer();

const httpTerminator = createHttpTerminator({
  server,
});

await httpTerminator.terminate();

Gajus
  • 69,002
  • 70
  • 275
  • 438
0

const Koa = require('koa')
const app = new Koa()

let keepAlive = true
app.use(async (ctx) => {
  let url = ctx.request.url

  // destroy socket
  if (keepAlive === false) {
    ctx.response.set('Connection', 'close')
  }
  switch (url) {
    case '/restart':
      ctx.body = 'success'
      process.send('restart')
      break;
    default:
      ctx.body = 'world-----' + Date.now()
  }
})
const server = app.listen(9011)

process.on('message', (data, sendHandle) => {
  if (data == 'stop') {
    keepAlive = false
    server.close();
  }
})
vapour
  • 31
  • 2
0

Finally, we have server.closeAllConnections() function in v18.2.0

You can just call this function before server.close().

Also, if you don't want close active connections and want to wait for them, call server.closeIdleConnections() function before server.close().

-5

process.exit(code); // code 0 for success and 1 for fail