zombie processes nodejs

Daemonize a node process

This example shows how to daemonize a Node.js process by re-spawning it in a new session with the `IS_DAEMONIC` environment variable set. It uses the `child_process.spawn` API to launch `/bin/sh` with a command that runs `setsid` on the original script, redirecting output to `/dev/null` and detaching it from the terminal. The code also escapes shell metacharacters in the process arguments to ensure safe quoting. After spawning, the parent process exits via a `stop()` call, leaving the daemon running independently.

66% match

node-websocketd

This example demonstrates a lightweight Node.js port of the websocketd tool, which exposes a command-line script over a WebSocket connection. It shows how a spawned child process can receive input from and send output to a connected browser client in real time. The implementation uses the `ws` Server to handle WebSocket connections, `websocket-stream` to create a duplex stream over the socket, and `child_process.spawn` to execute the user-supplied command. Standard input and output are piped between the stream and the spawned process, with the process being killed when the stream ends.

59% match

Gist 597373

This example shows a Node.js script that attempts to process crime incident data from a CSV file using the `ecsv` library, but it fails due to a system resource limit. The code calls `exec('wc -c "foo"', ...)` inside the `ecsv.each` callback for every row, spawning a new child process for each record. The visible stack trace from `child_process.spawn` reveals the error "Too many open files," indicating the script exhausts file descriptors because it launches processes asynchronously without waiting for completion. The gist demonstrates a common anti-pattern where unthrottled asynchronous process spawning overwhelms the operating system, using only Node.js core APIs (`child_process.exec`, `fs`) and the third-party `ecsv` parser.

CCaged

55% match

Gist 4521887

This example shows a shell-command supervisor that forks a child process, monitors its exit status, and restarts it on failure. The code uses POSIX APIs including `fork()`, `execl()`, `waitpid()`, and `signal()` to launch and track the command, while logging each step. It writes a pidfile, tracks restart timing with `timestamp()` and `ms_since_last_restart()`, and bails after exceeding `max_attempts` within a time window, executing an error command if configured. The visualization is a plain C source file, not a graphical chart, demonstrating process lifecycle logic.

Aallyraza

54% match

Gist 58d08353ae4a8a72f84a

This example demonstrates a debugging technique for retrieving a JavaScript stack trace from a Node.js process stuck in an infinite loop. It shows the step-by-step process of attaching GDB to the running process, setting a breakpoint at `v8::internal::Runtime_StackGuard`, and triggering `v8::V8::TerminateExecution` to reach a safe point where V8 can print the trace via `V8_Fatal`. The output reveals the JavaScript call stack, including function names and file locations.

init.d script for node.js for debian

This example presents a Debian init script for running Node.js server applications as background daemons. The script uses the standard `/etc/init.d` skeleton and LSB init headers to define start/stop behavior across runlevels. It launches the app via the `nave` node version manager, specifying the node version and server path in `DAEMON_ARGS`, while supporting automatic PID file creation, user switching via `--chuid`, and optional integration with `update-rc.d` for boot-time management.

Node.js + Socket.io + Bash. A collaborative terminal for your browser.

This example demonstrates a collaborative terminal in the browser, where multiple users share a live bash session and see each other’s commands and output in real time. It shows a simple web page that displays the shell’s stdout and stderr as a scrolling log, while a text input lets any connected client send commands to the server. The server uses Node.js’s `child_process.spawn` to launch bash, and Socket.io’s `listen` and `broadcast` methods to relay data between the shell and all clients. The client-side `term.html` uses jQuery for DOM updates and Socket.io’s `io.Socket` for message handling, rendering each line as a `<p>` element.

Aackuser

Node command line read from input (hope I get this working)

This example demonstrates a minimal interactive command-line interface in Node.js. It reads user input from standard input, echoes the entered text with a prompt prefix, and terminates when the user types “exit”. The code uses `process.openStdin()` to access the input stream, sets its encoding to UTF-8, and registers a data event handler via `stdin.on('data', ...)` to process each line of input. No external libraries are required; it relies solely on Node.js built-in process and stream APIs.