source: frontend/node_modules/execa/lib/kill.js

'use strict';
const os = require('os');
const onExit = require('signal-exit');

const DEFAULT_FORCE_KILL_TIMEOUT = 1000 * 5;

// Monkey-patches `childProcess.kill()` to add `forceKillAfterTimeout` behavior
const spawnedKill = (kill, signal = 'SIGTERM', options = {}) => {
        const killResult = kill(signal);
        setKillTimeout(kill, signal, options, killResult);
        return killResult;
};

const setKillTimeout = (kill, signal, options, killResult) => {
        if (!shouldForceKill(signal, options, killResult)) {
                return;
        }

        const timeout = getForceKillAfterTimeout(options);
        const t = setTimeout(() => {
                kill('SIGKILL');
        }, timeout);

        // Guarded because there's no `.unref()` when `execa` is used in the renderer
        // process in Electron. This cannot be tested since we don't run tests in
        // Electron.
        // istanbul ignore else
        if (t.unref) {
                t.unref();
        }
};

const shouldForceKill = (signal, {forceKillAfterTimeout}, killResult) => {
        return isSigterm(signal) && forceKillAfterTimeout !== false && killResult;
};

const isSigterm = signal => {
        return signal === os.constants.signals.SIGTERM ||
                (typeof signal === 'string' && signal.toUpperCase() === 'SIGTERM');
};

const getForceKillAfterTimeout = ({forceKillAfterTimeout = true}) => {
        if (forceKillAfterTimeout === true) {
                return DEFAULT_FORCE_KILL_TIMEOUT;
        }

        if (!Number.isFinite(forceKillAfterTimeout) || forceKillAfterTimeout < 0) {
                throw new TypeError(`Expected the \`forceKillAfterTimeout\` option to be a non-negative integer, got \`${forceKillAfterTimeout}\` (${typeof forceKillAfterTimeout})`);
        }

        return forceKillAfterTimeout;
};

// `childProcess.cancel()`
const spawnedCancel = (spawned, context) => {
        const killResult = spawned.kill();

        if (killResult) {
                context.isCanceled = true;
        }
};

const timeoutKill = (spawned, signal, reject) => {
        spawned.kill(signal);
        reject(Object.assign(new Error('Timed out'), {timedOut: true, signal}));
};

// `timeout` option handling
const setupTimeout = (spawned, {timeout, killSignal = 'SIGTERM'}, spawnedPromise) => {
        if (timeout === 0 || timeout === undefined) {
                return spawnedPromise;
        }

        let timeoutId;
        const timeoutPromise = new Promise((resolve, reject) => {
                timeoutId = setTimeout(() => {
                        timeoutKill(spawned, killSignal, reject);
                }, timeout);
        });

        const safeSpawnedPromise = spawnedPromise.finally(() => {
                clearTimeout(timeoutId);
        });

        return Promise.race([timeoutPromise, safeSpawnedPromise]);
};

const validateTimeout = ({timeout}) => {
        if (timeout !== undefined && (!Number.isFinite(timeout) || timeout < 0)) {
                throw new TypeError(`Expected the \`timeout\` option to be a non-negative integer, got \`${timeout}\` (${typeof timeout})`);
        }
};

// `cleanup` option handling
const setExitHandler = async (spawned, {cleanup, detached}, timedPromise) => {
        if (!cleanup || detached) {
                return timedPromise;
        }

        const removeExitHandler = onExit(() => {
                spawned.kill();
        });

        return timedPromise.finally(() => {
                removeExitHandler();
        });
};

module.exports = {
        spawnedKill,
        spawnedCancel,
        setupTimeout,
        validateTimeout,
        setExitHandler
};