Graceful shutdown handling in Node.js - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What happens when the server receives SIGINT?

Consider this Node.js server code snippet that listens for the SIGINT signal to perform a graceful shutdown. What will be the output when you press Ctrl+C in the terminal?

Node.js

import http from 'http';

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

server.listen(3000, () => {
  console.log('Server running on port 3000');
});

process.on('SIGINT', () => {
  console.log('SIGINT received, closing server...');
  server.close(() => {
    console.log('Server closed');
    process.exit(0);
  });
});

A Server running on port 3000\nServer closed\nSIGINT received, closing server...

B Server running on port 3000\nSIGINT received, closing server...\n(process hangs, no further output)

C Server running on port 3000\nSIGINT received, closing server...\nServer closed

D Server running on port 3000\n(process exits immediately without logs)

💡 Hint

Think about the order of console logs and when server.close() callback runs.

When SIGINT is received, the handler logs the first message, then calls server.close(). Once the server finishes closing, the callback logs 'Server closed' and exits the process.

📝 Syntax

intermediate

Which option correctly handles server close with async/await?

You want to convert the server close logic to use async/await with a promise. Which code snippet correctly wraps server.close() in a promise?

Node.js

import http from 'http';

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

async function shutdown() {
  // Fill in the correct code here
}

process.on('SIGTERM', async () => {
  console.log('SIGTERM received');
  await shutdown();
  console.log('Shutdown complete');
  process.exit(0);
});

A await new Promise((resolve, reject) => server.close(err => err ? reject(err) : resolve()));

B await server.close();

C await new Promise(resolve => server.close(resolve));

D await new Promise((resolve, reject) => server.close(() => reject()));

💡 Hint

Remember server.close() uses a callback with an error argument.

Option A correctly wraps server.close() in a promise that resolves on success and rejects on error. Option A is invalid because server.close() does not return a promise. Option A ignores errors. Option A always rejects.

🔧 Debug

advanced

Why does the server not close on SIGINT?

Given this code, why does the server not close when pressing Ctrl+C?

Node.js

import http from 'http';

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

server.listen(4000);

process.on('SIGINT', () => {
  console.log('SIGINT received');
  server.close();
  console.log('Server closed');
  process.exit(0);
});

A Because the SIGINT event is not properly registered.

B Because <code>server.close()</code> is asynchronous and the process exits before it finishes closing.

C Because <code>server.close()</code> requires a callback to close the server.

D Because the server never started listening.

💡 Hint

Think about what happens when process.exit(0) runs immediately after server.close().

The server.close() method is asynchronous. Calling process.exit(0) immediately after it causes the process to exit before the server actually closes. The correct approach is to wait for the server.close() callback before exiting.

🧠 Conceptual

advanced

What is the main benefit of graceful shutdown in Node.js servers?

Why is implementing graceful shutdown important for Node.js servers?

A It improves server startup speed by caching modules.

B It automatically restarts the server after it crashes.

C It disables all incoming connections immediately to save resources.

D It allows the server to finish handling ongoing requests before closing, preventing data loss or errors.

💡 Hint

Think about what happens to active connections when the server closes abruptly.

Graceful shutdown ensures the server stops accepting new requests but finishes processing current ones, avoiding abrupt termination that could cause errors or data loss.

❓ state_output

expert

What is the output order when multiple shutdown signals are received?

Consider this code snippet. What will be the console output if the process receives SIGINT, then SIGTERM shortly after?

Node.js

import http from 'http';

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

server.listen(5000);

let shuttingDown = false;

async function shutdown(signal) {
  if (shuttingDown) {
    console.log(`Already shutting down on ${signal}`);
    return;
  }
  shuttingDown = true;
  console.log(`Shutdown started by ${signal}`);
  await new Promise(resolve => server.close(resolve));
  console.log('Server closed');
  process.exit(0);
}

process.on('SIGINT', () => shutdown('SIGINT'));
process.on('SIGTERM', () => shutdown('SIGTERM'));

A Shutdown started by SIGINT\nAlready shutting down on SIGTERM\nServer closed

B Shutdown started by SIGTERM\nAlready shutting down on SIGINT\nServer closed

C Shutdown started by SIGINT\nServer closed

D Shutdown started by SIGINT\nServer closed\nShutdown started by SIGTERM

💡 Hint

Consider the shuttingDown flag and the order signals are received.

The first signal (SIGINT) triggers shutdown and sets shuttingDown to true. The second signal (SIGTERM) triggers the handler but sees shuttingDown is true, so it logs 'Already shutting down on SIGTERM' and returns. The server closes once, then the process exits.