--- title: 'Process Managers' source: 'https://academia.sh/en/courses/backend-production/process-managers' course: 'Server Security and Going to Production' language: en updated: '2026-08-23T07:00:26+00:00' license: 'CC BY-SA 4.0' --- # Process Managers Two settings in the layer beneath the application: how immediate, backoff, and limited-attempt restart policies for a crashing process affect the dropped-request count; how many times the start loop turns under each policy when a process never starts; the difference between killing a process and letting it discard records and stay up when a memory limit is crossed; and how the wait time granted after a stop signal affects the number of drained requests. The previous lesson configured the layer in front of the application, and every one of its eight runs assumed one thing: the process was up, started by hand, stopped by hand when the job finished, and never crashed in between. In production, another component starts the process, restarts it when it crashes, decides how much memory it may use, and warns it before stopping it: the process manager. The proxy's settings changed what a request carried; this layer's settings change whether it gets answered at all. ## Two Settings, One Worker The process manager has two settings to measure. The first is the restart policy: how long to wait before restarting an exited process, and after how many attempts to give up. The second is the resource limit: how much memory a process may hold, and what happens when it is crossed. A third setting stands apart from both, just as silent: the wait time granted after a stop signal. - **SD1.** The worker allocates 2 MB per open loan record and reports its running total to the manager; the limit is enforced through that report. In a real deployment the value is read from the operating system. - **SD2.** A request's work takes a fixed duration. In the memory measurement, responses are staggered 100 milliseconds apart by acceptance order, so both the instant the limit is crossed and how many requests are in flight then are determined. - **SD3.** This lesson runs a single worker process; copy count is the next lesson's subject. The worker is the running form of the loan application, and takes four behaviors from a mode string. ```js // topology/worker.mjs — loan worker process. A mode string sets its behavior: // count= exits after answering n requests | start-fail=1 exits before it starts listening // work= one request's duration step= work grows by acceptance order (responses stagger) // memory=soft at the limit, discards the oldest half of records and stays up // shutdown=graceful|hard on the stop signal, drains pending requests or exits immediately import { createServer } from "node:http"; const [port, modeText] = [Number(process.argv[2]), process.argv[3] ?? ""]; const MODE = Object.fromEntries(modeText.split(",").filter(Boolean).map((p) => p.split("="))); const RECORD_MB = 2; // memory held per open loan record const LIMIT_MB = 40; // soft-limit threshold const held = []; let responded = 0, discarded = 0, accepted = 0, closing = false; if (Number.isInteger(port) === false) { console.log("usage: node topology/worker.mjs "); process.exit(0); } if (MODE["start-fail"] === "1") process.exit(9); const server = createServer((req, res) => { res.sendDate = false; if (closing) { res.writeHead(503).end("closing"); return; } const order = accepted++; held.push(new Array((RECORD_MB * 1024 * 1024) / 8).fill(1)); // an open loan record sits in memory if (MODE.memory === "soft" && held.length * RECORD_MB > LIMIT_MB) { discarded += held.splice(0, held.length >> 1).length; // oldest half discarded, process lives } setTimeout(() => { responded += 1; res.writeHead(200, { "x-held-mb": String(held.length * RECORD_MB) }).end("loan"); if (process.send !== undefined) process.send({ heldMB: held.length * RECORD_MB, responded, discarded }); if (MODE.count !== undefined && responded >= Number(MODE.count)) process.exit(9); }, Number(MODE.work ?? 40) + order * Number(MODE.step ?? 0)); }); process.on("SIGTERM", () => { if (MODE.shutdown === "graceful") { closing = true; server.close(() => process.exit(0)); } else process.exit(0); // pending requests drop without ever seeing a response }); server.listen(port, "127.0.0.1"); ``` The manager starts the worker, listens for its reports, catches its exit, and applies policy. ```js // topology/manager.mjs — process manager. Setting string: // policy=immediate|backoff|limited: memory=none|hard: // duration= 0 waits for the stop signal and prints a summary; >0 starts a graceful stop then // wait= time granted after the stop signal before a hard kill import { fork } from "node:child_process"; const [port, configText, workerMode, label] = [process.argv[2], process.argv[3] ?? "", process.argv[4] ?? "", process.argv[5] ?? "-"]; const OPTS = Object.fromEntries(configText.split(",").filter(Boolean).map((p) => p.split("="))); const BACKOFF = [100, 200, 400, 800, 1600]; // backoff ladder (ms) let attempts = 0, delay = 0, kills = 0, peak = 0, discarded = 0, gaveUp = false, stopping = false, child = null; function start() { let killed = false; child = fork("topology/worker.mjs", [port, workerMode], { stdio: ["ignore", "ignore", "ignore", "ipc"] }); child.on("message", (m) => { peak = Math.max(peak, m.heldMB); discarded = m.discarded; const hard = (OPTS.memory ?? "none").startsWith("hard:") ? Number(OPTS.memory.split(":")[1]) : Infinity; if (m.heldMB > hard && killed === false) { // limit crossed: process is killed killed = true; kills += 1; child.kill("SIGKILL"); } }); child.on("exit", () => { if (stopping === false) retry(); }); } function retry() { const max = (OPTS.policy ?? "").startsWith("limited:") ? Number(OPTS.policy.split(":")[1]) : Infinity; if (attempts >= max) { gaveUp = true; return; } const g = OPTS.policy === "backoff" ? BACKOFF[Math.min(attempts, BACKOFF.length - 1)] : 0; attempts += 1; delay += g; setTimeout(start, g); } if (port === undefined) console.log("usage: node topology/manager.mjs