http-terminator

What is http-terminator?

The http-terminator npm package provides a reliable way to gracefully terminate HTTP and HTTPS servers. It ensures that all active connections are properly closed before the server shuts down, preventing potential data loss or corruption.

What are http-terminator's main functionalities?

Graceful Server Termination

This feature allows you to gracefully terminate an HTTP server, ensuring that all active connections are properly closed before the server shuts down.

const { createHttpTerminator } = require('http-terminator');
const http = require('http');

const server = http.createServer((req, res) => {
  res.end('Hello, world!');
});

server.listen(3000);

const httpTerminator = createHttpTerminator({ server });

// To terminate the server gracefully
httpTerminator.terminate().then(() => {
  console.log('Server terminated');
});

Handling Long-Lived Connections

This feature demonstrates how http-terminator handles long-lived connections, ensuring they are properly closed before the server shuts down.

const { createHttpTerminator } = require('http-terminator');
const http = require('http');

const server = http.createServer((req, res) => {
  setTimeout(() => {
    res.end('Delayed response');
  }, 10000); // Simulate a long-lived connection
});

server.listen(3000);

const httpTerminator = createHttpTerminator({ server });

// To terminate the server gracefully
httpTerminator.terminate().then(() => {
  console.log('Server terminated');
});

Custom Termination Timeout

This feature allows you to set a custom timeout for graceful termination, giving you control over how long the server should wait before forcefully closing connections.

const { createHttpTerminator } = require('http-terminator');
const http = require('http');

const server = http.createServer((req, res) => {
  res.end('Hello, world!');
});

server.listen(3000);

const httpTerminator = createHttpTerminator({
  server,
  gracefulTerminationTimeout: 5000 // Custom timeout in milliseconds
});

// To terminate the server gracefully
httpTerminator.terminate().then(() => {
  console.log('Server terminated');
});

Other packages similar to http-terminator

stoppable

The stoppable package provides similar functionality by allowing you to gracefully stop an HTTP server. It ensures that existing connections are properly closed before the server shuts down. Compared to http-terminator, stoppable is simpler but may lack some advanced features and configurability.

http-shutdown

The http-shutdown package extends the Node.js HTTP server with a graceful shutdown capability. It ensures that all active connections are closed before the server shuts down. While it offers similar functionality to http-terminator, it may not be as actively maintained or feature-rich.

graceful-server

The graceful-server package provides a way to gracefully shut down HTTP servers, ensuring that all active connections are properly closed. It offers similar functionality to http-terminator but may have different configuration options and usage patterns.

README

http-terminator 🦾

Gracefully terminates HTTP(S) server.

• http-terminator 🦾
  • Behaviour
  • API
  • Usage
    • Usage with Express
    • Usage with Fastify
    • Usage with Koa
    • Usage with other HTTP frameworks
  • Alternative libraries
  • FAQ
    • What is the use case for http-terminator?

Behaviour

When you call server.close(), it stops the server from accepting new connections, but it keeps the existing connections open indefinitely. This can result in your server hanging indefinitely due to keep-alive connections or because of the ongoing requests that do not produce a response. Therefore, in order to close the server, you must track creation of all connections and terminate them yourself.

http-terminator implements the logic for tracking all connections and their termination upon a timeout. http-terminator also ensures graceful communication of the server intention to shutdown to any clients that are currently receiving response from this server.

API

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

/**
 * @property gracefulTerminationTimeout Number of milliseconds to allow for the active sockets to complete serving the response (default: 5000).
 * @property server Instance of http.Server.
 */
type HttpTerminatorConfigurationInputType = {|
  +gracefulTerminationTimeout?: number,
  +server: Server,
|};

/**
 * @property terminate Terminates HTTP server.
 */
type HttpTerminatorType = {|
  +terminate: () => Promise<void>,
|};


const httpTerminator: HttpTerminatorType = createHttpTerminator(
  configuration: HttpTerminatorConfigurationInputType
);

Usage

Use createHttpTerminator to create an instance of http-terminator and instead of using server.close(), use httpTerminator.terminate(), e.g.

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

const server = http.createServer();

const httpTerminator = createHttpTerminator({
  server,
});

await httpTerminator.terminate();

Usage with Express

Usage with Express example:

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

const app = express();

const server = app.listen();

const httpTerminator = createHttpTerminator({
  server,
});

await httpTerminator.terminate();

Usage with Fastify

Usage with Fastify example:

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

const app = fastify();

void app.listen(0);

const httpTerminator = createHttpTerminator({
  server: app.server,
});

await httpTerminator.terminate();

Usage with Koa

Usage with Koa example:

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

const app = new Koa();

const server = app.listen();

const httpTerminator = createHttpTerminator({
  server,
});

await httpTerminator.terminate();

Usage with other HTTP frameworks

As it should be clear from the usage examples for Node.js HTTP server, Express and Koa, http-terminator works by accessing an instance of a Node.js http.Server. To understand how to use http-terminator with your framework, identify how to access an instance of http.Server and use it to create a http-terminator instance.

Alternative libraries

There are several alternative libraries that implement comparable functionality, e.g.

• https://github.com/hunterloftis/stoppable
• https://github.com/thedillonb/http-shutdown
• https://github.com/tellnes/http-close
• https://github.com/sebhildebrandt/http-graceful-shutdown

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

FAQ

What is the use case for http-terminator?

To gracefully terminate a HTTP server.

We say that a service is gracefully terminated when service stops accepting new clients, but allows time to complete the existing requests.

There are several reasons to terminate services gracefully:

• Terminating a service gracefully ensures that the client experience is not affected (assuming the service is load-balanced).
• If your application is stateful, then when services are not terminated gracefully, you are risking data corruption.
• Forcing termination of the service with a timeout ensures timely termination of the service (otherwise the service can remain hanging indefinitely).