typescript-node-scripts/build/lib/processHandler.js

"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
var __importStar = (this && this.__importStar) || function (mod) {
    if (mod && mod.__esModule) return mod;
    var result = {};
    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
    result["default"] = mod;
    return result;
};
Object.defineProperty(exports, "__esModule", { value: true });
const chalk_1 = __importDefault(require("chalk"));
const child_process_1 = require("child_process");
const pstree_remy_1 = __importStar(require("pstree.remy"));
const platform_1 = require("../util/platform");
function invariant(condition, message) {
    if (!condition) {
        const err = new Error(message);
        err.name = 'Invariant Violation';
        throw err;
    }
}
class AppController {
    constructor(executablePath, argv) {
        this.state = {
            appRunning: false,
            proc: null,
            pid: null,
        };
        this.executablePath = executablePath;
        this.argv = argv;
    }
    stopApp() {
        return __awaiter(this, void 0, void 0, function* () {
            return new Promise(resolve => {
                if (this.state.appRunning) {
                    console.log('Sending SIGTERM signal to app...');
                    const { pid } = this.state;
                    const closeHandler = (code, signal) => {
                        this.setState({
                            appRunning: false,
                            proc: null,
                            pid: null,
                        });
                        resolve();
                    };
                    if (platform_1.isWindows()) {
                        child_process_1.exec('taskkill /pid ' + pid + ' /T /F').on('close', closeHandler);
                    }
                    else {
                        // pstree is used to kill the full subtree of a spawned app
                        pstree_remy_1.default(pid, (_, children) => {
                            if (pstree_remy_1.hasPS) {
                                // we now send SIGTERM to the spawned process
                                child_process_1.spawn('kill', ['-s', 'SIGTERM', pid].concat(children)).on('close', closeHandler);
                            }
                            else {
                                const pids = children.concat(pid).sort();
                                pids.forEach(childPid => {
                                    // 15 is for SIGTERM
                                    child_process_1.exec('kill -15 ' + childPid).on('close', closeHandler);
                                });
                            }
                        });
                    }
                }
                else {
                    resolve();
                }
            });
        });
    }
    runApp() {
        invariant(!this.state.appRunning, "Can't start app when app is already running!");
        // spawn the process
        const proc = child_process_1.spawn('node', [this.executablePath, ...this.argv]);
        // attach event listeners
        proc.on('error', e => {
            console.log(chalk_1.default.red('Failed to start app: ' + e.message));
            this.setState({
                appRunning: false,
                proc: null,
                pid: null,
            });
        });
        proc.on('exit', (code, signal) => {
            if (code !== null) {
                console.log(code > 0
                    ? chalk_1.default.red('App exited with code ' + code + '.')
                    : chalk_1.default.green('App exited with code ' + code + '.'));
            }
            if (signal !== null) {
                console.log(signal !== 'SIGTERM'
                    ? chalk_1.default.red('App killed with signal ' + signal + '.')
                    : chalk_1.default.green('App killed with signal SIGTERM.'));
            }
            this.setState({
                appRunning: false,
                proc: null,
                pid: null,
            });
        });
        // pipe spawned output stream to current process's output streams
        proc.stdout.pipe(process.stdout);
        proc.stderr.pipe(process.stderr);
        console.log(chalk_1.default.green('App started!'));
        this.setState({
            proc,
            pid: proc.pid.toString(),
            appRunning: true,
        });
    }
    setState(state) {
        this.state = state;
    }
}
exports.AppController = AppController;
//# sourceMappingURL=processHandler.js.map