concurrently 3.6.0 → 4.1.0

package/src/flow-control/kill-on-signal.spec.js

@@ -0,0 +1,70 @@
+const EventEmitter = require('events');
+
+const createFakeCommand = require('./fixtures/fake-command');
+const KillOnSignal = require('./kill-on-signal');
+
+let commands, controller, process;
+beforeEach(() => {
+    process = new EventEmitter();
+    commands = [
+        createFakeCommand(),
+        createFakeCommand(),
+    ];
+    controller = new KillOnSignal({ process });
+});
+
+it('returns commands that keep non-close streams from original commands', () => {
+    const newCommands = controller.handle(commands);
+    newCommands.forEach((newCommand, i) => {
+        expect(newCommand.close).not.toBe(commands[i].close);
+        expect(newCommand.error).toBe(commands[i].error);
+        expect(newCommand.stdout).toBe(commands[i].stdout);
+        expect(newCommand.stderr).toBe(commands[i].stderr);
+    });
+});
+
+it('returns commands that map SIGINT to exit code 0', () => {
+    const newCommands = controller.handle(commands);
+    expect(newCommands).not.toBe(commands);
+    expect(newCommands).toHaveLength(commands.length);
+
+    const callback = jest.fn();
+    newCommands[0].close.subscribe(callback);
+    process.emit('SIGINT');
+
+    // A fake command's .kill() call won't trigger a close event automatically...
+    commands[0].close.next(1);
+
+    expect(callback).not.toHaveBeenCalledWith('SIGINT');
+    expect(callback).toHaveBeenCalledWith(0);
+});
+
+it('returns commands that keep non-SIGINT exit codes', () => {
+    const newCommands = controller.handle(commands);
+    expect(newCommands).not.toBe(commands);
+    expect(newCommands).toHaveLength(commands.length);
+
+    const callback = jest.fn();
+    newCommands[0].close.subscribe(callback);
+    commands[0].close.next(1);
+
+    expect(callback).toHaveBeenCalledWith(1);
+});
+
+it('kills all commands on SIGINT', () => {
+    controller.handle(commands);
+    process.emit('SIGINT');
+
+    expect(process.listenerCount('SIGINT')).toBe(1);
+    expect(commands[0].kill).toHaveBeenCalledWith('SIGINT');
+    expect(commands[1].kill).toHaveBeenCalledWith('SIGINT');
+});
+
+it('kills all commands on SIGTERM', () => {
+    controller.handle(commands);
+    process.emit('SIGTERM');
+
+    expect(process.listenerCount('SIGTERM')).toBe(1);
+    expect(commands[0].kill).toHaveBeenCalledWith('SIGTERM');
+    expect(commands[1].kill).toHaveBeenCalledWith('SIGTERM');
+});

package/src/flow-control/kill-others.js

@@ -0,0 +1,35 @@
+const _ = require('lodash');
+const { filter, map } = require('rxjs/operators');
+
+module.exports = class KillOthers {
+    constructor({ logger, conditions }) {
+        this.logger = logger;
+        this.conditions = _.castArray(conditions);
+    }
+
+    handle(commands) {
+        const conditions = this.conditions.filter(condition => (
+            condition === 'failure' ||
+            condition === 'success'
+        ));
+
+        if (!conditions.length) {
+            return commands;
+        }
+
+        const closeStates = commands.map(command => command.close.pipe(
+            map(exitCode => exitCode === 0 ? 'success' : 'failure'),
+            filter(state => conditions.includes(state))
+        ));
+
+        closeStates.forEach(closeState => closeState.subscribe(() => {
+            const killableCommands = commands.filter(command => command.killable);
+            if (killableCommands.length) {
+                this.logger.logGlobalEvent('Sending SIGTERM to other processes..');
+                killableCommands.forEach(command => command.kill());
+            }
+        }));
+
+        return commands;
+    }
+};

package/src/flow-control/kill-others.spec.js

@@ -0,0 +1,66 @@
+const { createMockInstance } = require('jest-create-mock-instance');
+
+const Logger = require('../logger');
+const createFakeCommand = require('./fixtures/fake-command');
+const KillOthers = require('./kill-others');
+
+let commands, logger;
+beforeEach(() => {
+    commands = [
+        createFakeCommand(),
+        createFakeCommand()
+    ];
+
+    logger = createMockInstance(Logger);
+});
+
+const createWithConditions = conditions => new KillOthers({
+    logger,
+    conditions
+});
+
+it('returns same commands', () => {
+    expect(createWithConditions(['foo']).handle(commands)).toBe(commands);
+    expect(createWithConditions(['failure']).handle(commands)).toBe(commands);
+});
+
+it('does not kill others if condition does not match', () => {
+    createWithConditions(['failure']).handle(commands);
+    commands[1].killable = true;
+    commands[0].close.next(0);
+
+    expect(logger.logGlobalEvent).not.toHaveBeenCalled();
+    expect(commands[0].kill).not.toHaveBeenCalled();
+    expect(commands[1].kill).not.toHaveBeenCalled();
+});
+
+it('kills other killable processes on success', () => {
+    createWithConditions(['success']).handle(commands);
+    commands[1].killable = true;
+    commands[0].close.next(0);
+
+    expect(logger.logGlobalEvent).toHaveBeenCalledTimes(1);
+    expect(logger.logGlobalEvent).toHaveBeenCalledWith('Sending SIGTERM to other processes..');
+    expect(commands[0].kill).not.toHaveBeenCalled();
+    expect(commands[1].kill).toHaveBeenCalled();
+});
+
+it('kills other killable processes on failure', () => {
+    createWithConditions(['failure']).handle(commands);
+    commands[1].killable = true;
+    commands[0].close.next(1);
+
+    expect(logger.logGlobalEvent).toHaveBeenCalledTimes(1);
+    expect(logger.logGlobalEvent).toHaveBeenCalledWith('Sending SIGTERM to other processes..');
+    expect(commands[0].kill).not.toHaveBeenCalled();
+    expect(commands[1].kill).toHaveBeenCalled();
+});
+
+it('does not try to kill processes already dead', () => {
+    createWithConditions(['failure']).handle(commands);
+    commands[0].close.next(1);
+
+    expect(logger.logGlobalEvent).not.toHaveBeenCalled();
+    expect(commands[0].kill).not.toHaveBeenCalled();
+    expect(commands[1].kill).not.toHaveBeenCalled();
+});

package/src/flow-control/log-error.js

@@ -0,0 +1,20 @@
+const { of } = require('rxjs');
+
+module.exports = class LogExit {
+    constructor({ logger }) {
+        this.logger = logger;
+    }
+
+    handle(commands) {
+        commands.forEach(command => command.error.subscribe(event => {
+            this.logger.logCommandEvent(
+                `Error occurred when executing command: ${command.command}`,
+                command
+            );
+
+            this.logger.logCommandEvent(event.stack || event, command);
+        }));
+
+        return commands;
+    }
+};

package/src/flow-control/log-error.spec.js

@@ -0,0 +1,40 @@
+const { createMockInstance } = require('jest-create-mock-instance');
+const Logger = require('../logger');
+const LogError = require('./log-error');
+const createFakeCommand = require('./fixtures/fake-command');
+
+let controller, logger, commands;
+beforeEach(() => {
+    commands = [
+        createFakeCommand(),
+        createFakeCommand(),
+    ];
+
+    logger = createMockInstance(Logger);
+    controller = new LogError({ logger });
+});
+
+it('returns same commands', () => {
+    expect(controller.handle(commands)).toBe(commands);
+});
+
+it('logs the error event of each command', () => {
+    controller.handle(commands);
+    commands[0].error.next('error from command 0');
+
+    const error = new Error('some error message');
+    commands[1].error.next(error);
+
+    expect(logger.logCommandEvent).toHaveBeenCalledTimes(4);
+    expect(logger.logCommandEvent).toHaveBeenCalledWith(
+        `Error occurred when executing command: ${commands[0].command}`,
+        commands[0]
+    );
+    expect(logger.logCommandEvent).toHaveBeenCalledWith('error from command 0', commands[0]);
+
+    expect(logger.logCommandEvent).toHaveBeenCalledWith(
+        `Error occurred when executing command: ${commands[1].command}`,
+        commands[1]
+    );
+    expect(logger.logCommandEvent).toHaveBeenCalledWith(error.stack, commands[1]);
+});

package/src/flow-control/log-exit.js

@@ -0,0 +1,13 @@
+module.exports = class LogExit {
+    constructor({ logger }) {
+        this.logger = logger;
+    }
+
+    handle(commands) {
+        commands.forEach(command => command.close.subscribe(code => {
+            this.logger.logCommandEvent(`${command.command} exited with code ${code}`, command);
+        }));
+
+        return commands;
+    }
+};

package/src/flow-control/log-exit.spec.js

@@ -0,0 +1,36 @@
+const { createMockInstance } = require('jest-create-mock-instance');
+const Logger = require('../logger');
+const LogExit = require('./log-exit');
+const createFakeCommand = require('./fixtures/fake-command');
+
+let controller, logger, commands;
+beforeEach(() => {
+    commands = [
+        createFakeCommand(),
+        createFakeCommand(),
+    ];
+
+    logger = createMockInstance(Logger);
+    controller = new LogExit({ logger });
+});
+
+it('returns same commands', () => {
+    expect(controller.handle(commands)).toBe(commands);
+});
+
+it('logs the close event of each command', () => {
+    controller.handle(commands);
+
+    commands[0].close.next(0);
+    commands[1].close.next('SIGTERM');
+
+    expect(logger.logCommandEvent).toHaveBeenCalledTimes(2);
+    expect(logger.logCommandEvent).toHaveBeenCalledWith(
+        `${commands[0].command} exited with code 0`,
+        commands[0]
+    );
+    expect(logger.logCommandEvent).toHaveBeenCalledWith(
+        `${commands[1].command} exited with code SIGTERM`,
+        commands[1]
+    );
+});

package/src/flow-control/log-output.js

@@ -0,0 +1,14 @@
+module.exports = class LogOutput {
+    constructor({ logger }) {
+        this.logger = logger;
+    }
+
+    handle(commands) {
+        commands.forEach(command => {
+            command.stdout.subscribe(text => this.logger.logCommandText(text.toString(), command));
+            command.stderr.subscribe(text => this.logger.logCommandText(text.toString(), command));
+        });
+
+        return commands;
+    }
+};

package/src/flow-control/log-output.spec.js

@@ -0,0 +1,41 @@
+const { createMockInstance } = require('jest-create-mock-instance');
+const Logger = require('../logger');
+const LogOutput = require('./log-output');
+const createFakeCommand = require('./fixtures/fake-command');
+
+let controller, logger, commands;
+beforeEach(() => {
+    commands = [
+        createFakeCommand(),
+        createFakeCommand(),
+    ];
+
+    logger = createMockInstance(Logger);
+    controller = new LogOutput({ logger });
+});
+
+it('returns same commands', () => {
+    expect(controller.handle(commands)).toBe(commands);
+});
+
+it('logs the stdout of each command', () => {
+    controller.handle(commands);
+
+    commands[0].stdout.next(Buffer.from('foo'));
+    commands[1].stdout.next(Buffer.from('bar'));
+
+    expect(logger.logCommandText).toHaveBeenCalledTimes(2);
+    expect(logger.logCommandText).toHaveBeenCalledWith('foo', commands[0]);
+    expect(logger.logCommandText).toHaveBeenCalledWith('bar', commands[1]);
+});
+
+it('logs the stderr of each command', () => {
+    controller.handle(commands);
+
+    commands[0].stderr.next(Buffer.from('foo'));
+    commands[1].stderr.next(Buffer.from('bar'));
+
+    expect(logger.logCommandText).toHaveBeenCalledTimes(2);
+    expect(logger.logCommandText).toHaveBeenCalledWith('foo', commands[0]);
+    expect(logger.logCommandText).toHaveBeenCalledWith('bar', commands[1]);
+});

package/src/flow-control/restart-process.js

@@ -0,0 +1,51 @@
+const Rx = require('rxjs');
+const { defaultIfEmpty, delay, filter, mapTo, skip, take, takeWhile } = require('rxjs/operators');
+
+const defaults = require('../defaults');
+
+module.exports = class RestartProcess {
+    constructor({ delay, tries, logger, scheduler }) {
+        this.delay = +delay || defaults.restartDelay;
+        this.tries = +tries || defaults.restartTries;
+        this.logger = logger;
+        this.scheduler = scheduler;
+    }
+
+    handle(commands) {
+        if (this.tries === 0) {
+            return commands;
+        }
+
+        commands.map(command => command.close.pipe(
+            take(this.tries),
+            takeWhile(code => code !== 0)
+        )).map((failure, index) => Rx.merge(
+            // Delay the emission (so that the restarts happen on time),
+            // explicitly telling the subscriber that a restart is needed
+            failure.pipe(delay(this.delay, this.scheduler), mapTo(true)),
+            // Skip the first N emissions (as these would be duplicates of the above),
+            // meaning it will be empty because of success, or failed all N times,
+            // and no more restarts should be attempted.
+            failure.pipe(skip(this.tries), defaultIfEmpty(false))
+        ).subscribe(restart => {
+            const command = commands[index];
+            if (restart) {
+                this.logger.logCommandEvent(`${command.command} restarted`, command);
+                command.start();
+            }
+        }));
+
+        return commands.map(command => {
+            const closeStream = command.close.pipe(filter((value, emission) => {
+                // We let all success codes pass, and failures only after restarting won't happen again
+                return value === 0 || emission >= this.tries;
+            }));
+
+            return new Proxy(command, {
+                get(target, prop) {
+                    return prop === 'close' ? closeStream : target[prop];
+                }
+            });
+        });
+    }
+};

package/src/flow-control/restart-process.spec.js

@@ -0,0 +1,129 @@
+const { createMockInstance } = require('jest-create-mock-instance');
+const { TestScheduler } = require('rxjs/testing');
+
+const Logger = require('../logger');
+const createFakeCommand = require('./fixtures/fake-command');
+const RestartProcess = require('./restart-process');
+
+let commands, controller, logger, scheduler;
+beforeEach(() => {
+    commands = [
+        createFakeCommand(),
+        createFakeCommand()
+    ];
+
+    logger = createMockInstance(Logger);
+    scheduler = new TestScheduler();
+    controller = new RestartProcess({
+        logger,
+        scheduler,
+        delay: 100,
+        tries: 2
+    });
+});
+
+it('does not restart processes that complete with success', () => {
+    controller.handle(commands);
+
+    commands[0].close.next(0);
+    commands[1].close.next(0);
+
+    scheduler.flush();
+
+    expect(commands[0].start).toHaveBeenCalledTimes(0);
+    expect(commands[1].start).toHaveBeenCalledTimes(0);
+});
+
+it('restarts processes that fail after delay has passed', () => {
+    controller.handle(commands);
+
+    commands[0].close.next(1);
+    commands[1].close.next(0);
+
+    scheduler.flush();
+
+    expect(logger.logCommandEvent).toHaveBeenCalledTimes(1);
+    expect(logger.logCommandEvent).toHaveBeenCalledWith(
+        `${commands[0].command} restarted`,
+        commands[0]
+    );
+    expect(commands[0].start).toHaveBeenCalledTimes(1);
+    expect(commands[1].start).not.toHaveBeenCalled();
+});
+
+it('restarts processes up to tries', () => {
+    controller.handle(commands);
+
+    commands[0].close.next(1);
+    commands[0].close.next('SIGTERM');
+    commands[0].close.next('SIGTERM');
+    commands[1].close.next(0);
+
+    scheduler.flush();
+
+    expect(logger.logCommandEvent).toHaveBeenCalledTimes(2);
+    expect(logger.logCommandEvent).toHaveBeenCalledWith(
+        `${commands[0].command} restarted`,
+        commands[0]
+    );
+    expect(commands[0].start).toHaveBeenCalledTimes(2);
+});
+
+it('restarts processes until they succeed', () => {
+    controller.handle(commands);
+
+    commands[0].close.next(1);
+    commands[0].close.next(0);
+    commands[1].close.next(0);
+
+    scheduler.flush();
+
+    expect(logger.logCommandEvent).toHaveBeenCalledTimes(1);
+    expect(logger.logCommandEvent).toHaveBeenCalledWith(
+        `${commands[0].command} restarted`,
+        commands[0]
+    );
+    expect(commands[0].start).toHaveBeenCalledTimes(1);
+});
+
+describe('returned commands', () => {
+    it('are the same if 0 tries are to be attempted', () => {
+        controller = new RestartProcess({ logger, scheduler });
+        expect(controller.handle(commands)).toBe(commands);
+    });
+
+    it('are not the same, but with same length if 1+ tries are to be attempted', () => {
+        const newCommands = controller.handle(commands);
+        expect(newCommands).not.toBe(commands);
+        expect(newCommands).toHaveLength(commands.length);
+    });
+
+    it('skip close events followed by restarts', () => {
+        const newCommands = controller.handle(commands);
+
+        const callback = jest.fn();
+        newCommands[0].close.subscribe(callback);
+        newCommands[1].close.subscribe(callback);
+
+        commands[0].close.next(1);
+        commands[0].close.next(1);
+        commands[0].close.next(1);
+        commands[1].close.next(1);
+        commands[1].close.next(0);
+
+        scheduler.flush();
+
+        // 1 failure from commands[0], 1 success from commands[1]
+        expect(callback).toHaveBeenCalledTimes(2);
+    });
+
+    it('keep non-close streams from original commands', () => {
+        const newCommands = controller.handle(commands);
+        newCommands.forEach((newCommand, i) => {
+            expect(newCommand.close).not.toBe(commands[i].close);
+            expect(newCommand.error).toBe(commands[i].error);
+            expect(newCommand.stdout).toBe(commands[i].stdout);
+            expect(newCommand.stderr).toBe(commands[i].stderr);
+        });
+    });
+});

package/src/get-spawn-opts.js

@@ -0,0 +1,12 @@
+const supportsColor = require('supports-color');
+
+module.exports = ({
+    colorSupport = supportsColor,
+    process = global.process,
+    raw = false
+} = {}) => Object.assign(
+    {},
+    raw && { stdio: 'inherit' },
+    /^win/.test(process.platform) && { detached: false },
+    colorSupport && { env: Object.assign({ FORCE_COLOR: colorSupport.level }, process.env) }
+);

package/src/get-spawn-opts.spec.js

@@ -0,0 +1,18 @@
+const getSpawnOpts = require('./get-spawn-opts');
+
+it('sets detached mode to false for Windows platform', () => {
+    expect(getSpawnOpts({ process: { platform: 'win32' } }).detached).toBe(false);
+});
+
+it('sets stdio to inherit when raw', () => {
+    expect(getSpawnOpts({ raw: true }).stdio).toBe('inherit');
+});
+
+it('merges FORCE_COLOR into env vars if color supported', () => {
+    const process = { env: { foo: 'bar' } };
+    expect(getSpawnOpts({ process, colorSupport: false }).env).toBeUndefined();
+    expect(getSpawnOpts({ process, colorSupport: { level: 1 } }).env).toEqual({
+        FORCE_COLOR: 1,
+        foo: 'bar'
+    });
+});

package/src/logger.js

@@ -0,0 +1,109 @@
+const chalk = require('chalk');
+const _ = require('lodash');
+const formatDate = require('date-fns/format');
+
+const defaults = require('./defaults');
+
+module.exports = class Logger {
+    constructor({ outputStream, prefixFormat, prefixLength, raw, timestampFormat }) {
+        this.raw = raw;
+        this.outputStream = outputStream;
+        this.prefixFormat = prefixFormat;
+        this.prefixLength = prefixLength || defaults.prefixLength;
+        this.timestampFormat = timestampFormat || defaults.timestampFormat;
+    }
+
+    shortenText(text) {
+        if (!text || text.length <= this.prefixLength) {
+            return text;
+        }
+
+        const ellipsis = '..';
+        const prefixLength = this.prefixLength - ellipsis.length;
+        const endLength = Math.floor(prefixLength / 2);
+        const beginningLength = prefixLength - endLength;
+
+        const beginnning = text.substring(0, beginningLength);
+        const end = text.substring(text.length - endLength, text.length);
+        return beginnning + ellipsis + end;
+    }
+
+    getPrefixesFor(command) {
+        return {
+            none: '',
+            pid: command.pid,
+            index: command.index,
+            name: command.name,
+            command: this.shortenText(command.command),
+            time: formatDate(Date.now(), this.timestampFormat)
+        };
+    }
+
+    getPrefix(command) {
+        const prefix = this.prefixFormat || (command.name ? 'name' : 'index');
+        if (prefix === 'none') {
+            return '';
+        }
+
+        const prefixes = this.getPrefixesFor(command);
+        if (Object.keys(prefixes).includes(prefix)) {
+            return `[${prefixes[prefix]}]`;
+        }
+
+        return _.reduce(prefixes, (prev, val, key) => {
+            const keyRegex = new RegExp(_.escapeRegExp(`{${key}}`), 'g');
+            return prev.replace(keyRegex, val);
+        }, prefix).trim();
+    }
+
+    colorText(command, text) {
+        const color = _.get(chalk, command.prefixColor, chalk.gray.dim);
+        return color(text);
+    }
+
+    logCommandEvent(text, command) {
+        if (this.raw) {
+            return;
+        }
+
+        this.logCommandText(chalk.gray.dim(text) + '\n', command);
+    }
+
+    logCommandText(text, command) {
+        const prefix = this.colorText(command, this.getPrefix(command));
+        return this.log(prefix + (prefix ? ' ' : ''), text);
+    }
+
+    logGlobalEvent(text) {
+        if (this.raw) {
+            return;
+        }
+
+        this.log(chalk.gray.dim('-->') + ' ', chalk.gray.dim(text) + '\n');
+    }
+
+    log(prefix, text) {
+        if (this.raw) {
+            return this.outputStream.write(text);
+        }
+
+        // #70 - replace some ANSI code that would impact clearing lines
+        text = text.replace(/\u2026/g, '...');
+
+        const lines = text.split('\n').map((line, index, lines) => {
+            // First line will write prefix only if we finished the last write with a LF.
+            // Last line won't write prefix because it should be empty.
+            if (index === 0 || index === lines.length - 1) {
+                return line;
+            }
+            return prefix + line;
+        });
+
+        if (!this.lastChar || this.lastChar === '\n') {
+            this.outputStream.write(prefix);
+        }
+
+        this.lastChar = text[text.length - 1];
+        this.outputStream.write(lines.join('\n'));
+    }
+};