Ability to kill all descendents of the child process

[callumlocke]

When I'm working with child processes, I sometimes end up with detached processes running indefinitely after I've killed the direct child, which can lead to blocked ports and memory leaks.

I sometimes fix this by using a module like ps-tree to find out all the descendants PIDs, and then send all of them a kill command, but it feels messy. It would be nice if execa could provide a clean, cross-platform API for this.

Maybe something like this:

const execa = require('execa');

const child = execa('./something');

// ...

child.killTree().then(() => {
  console.log('all dead!');
});

[tomsotte]

Hi,

I've tried to implement a possible solution by using the pid range hack. I think it integrates in what execa already provides, which is a better child_process with cross-platform support. On Windows, when killing a process it would kill all of it descendents, but this does not happen on Linux (and apparently on macOS too).

The solution I've implemented replaces:

• the way execa kills the spawned process for the cleanup routine
• the ChildProcess#kill method

It shouldn't and doesn't AFAIK interfere with the detached and cleanup choice. But I'd like if someone can review and double-check it.

[sindresorhus]

See: #170 (comment)

[ehmicky]

Note that this is especially problematic when using shell: true.

The following:

const subprocess = execa('sleep 200', {shell: true});
subprocess.kill();
await subprocess;

Is the same as:

const subprocess = execa('/bin/sh', ['-c', 'sleep 200']);
subprocess.kill();
await subprocess;

This kills /bin/sh but not sleep 200, which is a separate process spawned by /bin/sh.

Note that both the shell: true behavior and the fact that descendant child processes are not recursively killed are not specific issues to Execa, but to core child_process.spawn() (that Execa is based upon).

[gaggle]

FWIW, I use a possible workaround (of sorts...), posting it here for others who might have the same issue and come across this thread. But.. it ain't pretty, and YMMW for its usefulness:

import execa, { ExecaChildProcess } from "execa"
import pidtree from "pidtree"

export type Execa2ChildProcess = ExecaChildProcess & { killTree: () => Promise<boolean> }

export function execa2Command (cmd: string, opts: { cwd?: string; shell?: boolean; } = {}): Execa2ChildProcess {
  const p = execa.command(cmd, opts)

  async function killTree (): Promise<boolean> {
    let pids
    try {
      pids = await pidtree(p.pid, { root: true })
    } catch (err) {
      if (err.message === "No maching pid found") return true // *
      throw err
    }
    pids.map(el => {
      try {
        process.kill(el)
      } catch (err) {
        if (err.code !== "ESRCH") throw err
      }
    })
    p.kill()
    return true
  }

  (p as any).killTree = killTree
  return p as ExecerChildProcess
}

* the error-message from pidtree is misspelled, PR simonepri/pidtree#11 attempts to fix that

This solution won't win any prizes and is maybe provably wrong in key areas, but it at least satisfies my test-suite so I can move on in my tasks.

[ehmicky]

This solution (pidtree) started to be implemented in this PR. We first looked into build this into childProcess.kill(). But it turns out it was big enough that we thought this should either be its own library or be built in core Node.js itself.

[fivethreeo]

Here is a good way to do this

https://www.npmjs.com/package/terminate

const terminate = require('terminate');

const subprocess = execa("yarn", ["start"], {stdio: 'inherit', cwd: tempDir })

terminate(subprocess.pid, 'SIGINT', { timeout: 1000 }, () => {
  terminate(subprocess.pid);
});