@terascope/scripts/dist/src/helpers/scripts.js

"use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
}) : (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
    Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
    o["default"] = v;
});
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)) __createBinding(result, mod, k);
    __setModuleDefault(result, mod);
    return result;
};
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.yarnPublish = exports.mapToArgs = exports.getChangedFiles = exports.gitDiff = exports.getCommitHash = exports.pgrep = exports.dockerPush = exports.dockerBuild = exports.dockerContainerReady = exports.dockerRun = exports.remoteDockerImageExists = exports.dockerNetworkExists = exports.getContainerInfo = exports.dockerTag = exports.dockerStop = exports.dockerPull = exports.runJest = exports.yarnRun = exports.setup = exports.build = exports.runTSScript = exports.fork = exports.exec = void 0;
const ms_1 = __importDefault(require("ms"));
const path_1 = __importDefault(require("path"));
const execa_1 = __importDefault(require("execa"));
const fs_extra_1 = __importDefault(require("fs-extra"));
const utils_1 = require("@terascope/utils");
const misc_1 = require("./misc");
const signale_1 = __importDefault(require("./signale"));
const config = __importStar(require("./config"));
const logger = utils_1.debugLogger('ts-scripts:cmd');
function _exec(opts) {
    let subprocess;
    const options = {
        cwd: opts.cwd || misc_1.getRootDir(),
        env: opts.env,
        preferLocal: true,
        detached: opts.detached,
        timeout: opts.timeout,
        stdio: opts.stdio,
    };
    logger.debug('executing command', opts);
    if (opts.args && opts.args.length) {
        subprocess = execa_1.default(opts.cmd, opts.args, options);
    }
    else {
        subprocess = execa_1.default(opts.cmd, options);
    }
    if (!subprocess) {
        throw new Error(`Failed to execution ${opts.cmd}`);
    }
    if (!opts.stdio) {
        if (!subprocess.stderr || !subprocess.stdout) {
            throw new Error(`Command ${opts.cmd} failed, stderr or stdout is not available`);
        }
        subprocess.stderr.pipe(process.stderr);
    }
    return subprocess;
}
async function exec(opts, log = true) {
    try {
        const env = { FORCE_COLOR: '0', ...opts.env };
        const _opts = { ...opts };
        _opts.env = env;
        const subprocess = _exec(_opts);
        const { stdout } = await subprocess;
        const result = stdout.trim();
        logger.debug(`exec result: ${opts.cmd} ${(opts.args || []).join(' ')}`, log && result);
        return result;
    }
    catch (err) {
        if (!err.command) {
            throw err;
        }
        process.exitCode = err.exitCode || 1;
        throw new Error(err.message);
    }
}
exports.exec = exec;
async function fork(opts) {
    try {
        const env = {
            FORCE_COLOR: config.FORCE_COLOR,
            ...opts.env
        };
        const _opts = { stdio: 'inherit', ...opts };
        _opts.env = env;
        await _exec(_opts);
    }
    catch (err) {
        if (!err.command) {
            throw err;
        }
        process.exitCode = err.exitCode || 1;
        throw new Error(err.message);
    }
}
exports.fork = fork;
async function runTSScript(cmd, args) {
    const scriptName = process.argv[1];
    return fork({
        cmd: scriptName,
        args: [cmd, ...args],
    });
}
exports.runTSScript = runTSScript;
async function build(pkgInfo) {
    if (pkgInfo) {
        const distDir = path_1.default.join(pkgInfo.dir, 'dist');
        if (fs_extra_1.default.existsSync(distDir)) {
            await fs_extra_1.default.emptyDir(distDir);
        }
        await yarnRun('build', [], pkgInfo.dir);
        return;
    }
    await yarnRun('build');
}
exports.build = build;
async function setup() {
    await yarnRun('setup');
}
exports.setup = setup;
async function yarnRun(script, args = [], cwd, env, log) {
    const dir = cwd || misc_1.getRootDir();
    const pkgJSON = await fs_extra_1.default.readJSON(path_1.default.join(dir, 'package.json'));
    const hasScript = Boolean(utils_1.get(pkgJSON, ['scripts', script]));
    if (!hasScript)
        return;
    const _args = ['run', script, ...args];
    if (log) {
        signale_1.default.info(`running yarn ${_args.join(' ')}...`);
    }
    await fork({
        cmd: 'yarn', args: _args, cwd: dir, env
    });
}
exports.yarnRun = yarnRun;
async function runJest(cwd, argsMap, env, extraArgs, debug) {
    const args = mapToArgs(argsMap);
    if (extraArgs) {
        extraArgs.forEach((extraArg) => {
            if (extraArg.startsWith('-') && args.includes(extraArg)) {
                if (debug) {
                    logger.debug(`* skipping duplicate jest arg ${extraArg}`);
                }
                return;
            }
            args.push(extraArg);
        });
    }
    if (debug) {
        signale_1.default.debug(`executing: jest ${args.join(' ')}`);
    }
    await fork({
        cmd: 'jest',
        cwd,
        args,
        env,
    });
}
exports.runJest = runJest;
async function dockerPull(image, timeout = 0) {
    try {
        await exec({
            cmd: 'docker',
            args: ['pull', image],
            timeout,
        });
    }
    catch (err) {
        process.exitCode = 0;
        throw err;
    }
}
exports.dockerPull = dockerPull;
async function dockerStop(name) {
    await exec({
        cmd: 'docker',
        args: ['stop', name],
    });
}
exports.dockerStop = dockerStop;
async function dockerTag(from, to) {
    await exec({
        cmd: 'docker',
        args: ['tag', from, to],
    });
}
exports.dockerTag = dockerTag;
async function getContainerInfo(name) {
    const result = await exec({
        cmd: 'docker',
        args: ['ps', '--format={{json .}}', `--filter=name=${name}`],
    });
    if (!result)
        return null;
    return JSON.parse(result);
}
exports.getContainerInfo = getContainerInfo;
async function dockerNetworkExists(name) {
    const subprocess = await execa_1.default.command(`docker network ls --format='{{json .Name}}' | grep '"${name}"'`, { reject: false });
    return subprocess.exitCode > 0;
}
exports.dockerNetworkExists = dockerNetworkExists;
async function remoteDockerImageExists(image) {
    try {
        await dockerPull(image, ms_1.default('30s'));
        return true;
    }
    catch (err) {
        return false;
    }
}
exports.remoteDockerImageExists = remoteDockerImageExists;
async function dockerRun(opt, tag = 'latest', debug) {
    const args = ['run', '--rm'];
    if (!opt.image) {
        throw new Error('Missing required image option');
    }
    if (!opt.name) {
        throw new Error('Missing required name option');
    }
    if (opt.ports && opt.ports.length) {
        opt.ports.forEach((port) => {
            if (utils_1.isString(port)) {
                args.push('--publish', port);
            }
            else {
                args.push('--publish', `${port}:${port}`);
            }
        });
    }
    if (opt.env) {
        Object.entries(opt.env).forEach(([key, val]) => {
            args.push('--env', `${key}=${val}`);
        });
    }
    if (opt.tmpfs && opt.tmpfs.length) {
        args.push('--tmpfs', opt.tmpfs.join(','));
    }
    if (opt.network) {
        const exists = await dockerNetworkExists(opt.network);
        if (!exists) {
            throw new Error(`Docker network ${opt.network} does not exist`);
        }
        args.push('--network', opt.network);
    }
    args.push('--name', opt.name);
    args.push(`${opt.image}:${tag}`);
    let error;
    let stderr;
    let done = true;
    if (debug) {
        signale_1.default.debug(`executing: docker ${args.join(' ')}`);
    }
    const subprocess = execa_1.default('docker', args);
    if (!subprocess || !subprocess.stderr) {
        throw new Error('Failed to execute docker run');
    }
    (async () => {
        done = false;
        try {
            const result = await subprocess;
            if (result.exitCode > 0) {
                stderr = result.all;
                error = new Error(`${result.command} failed`);
            }
        }
        catch (err) {
            error = err.stack;
            stderr = err.all;
        }
        finally {
            done = true;
        }
    })();
    const upFor = ms_1.default('5s');
    await utils_1.pWhile(() => dockerContainerReady(opt.name, upFor), {
        timeoutMs: ms_1.default('1m')
    });
    if (error) {
        if (stderr) {
            process.stderr.write(stderr);
        }
        throw error;
    }
    if (done) {
        throw new Error('Service ended early');
    }
    return () => {
        if (error) {
            if (stderr) {
                process.stderr.write(stderr);
            }
            signale_1.default.error(error);
        }
        if (done && !subprocess.killed)
            return;
        subprocess.kill();
    };
}
exports.dockerRun = dockerRun;
async function dockerContainerReady(name, upFor) {
    try {
        const result = await exec({
            cmd: 'docker',
            args: [
                'ps', '--format', '"{{json .Status}}"', '--filter', `name=${name}`
            ]
        });
        const timeup = ms_1.default(result.replace(/[(Up)\s"]+|/ig, ''));
        if (!timeup)
            return false;
        return timeup >= upFor;
    }
    catch (err) {
        await utils_1.pDelay(1000);
        return false;
    }
}
exports.dockerContainerReady = dockerContainerReady;
async function dockerBuild(tag, cacheFrom = [], target, buildArg) {
    const cacheFromArgs = [];
    cacheFrom.forEach((image) => {
        cacheFromArgs.push('--cache-from', image);
    });
    const targetArgs = target ? ['--target', target] : [];
    const buildsArgs = buildArg ? ['--build-arg', buildArg] : [];
    await fork({
        cmd: 'docker',
        args: ['build', ...cacheFromArgs, ...targetArgs, ...buildsArgs, '--tag', tag, '.'],
    });
}
exports.dockerBuild = dockerBuild;
async function dockerPush(image) {
    const subprocess = await execa_1.default.command(`docker push ${image}`, { reject: false });
    if (subprocess.exitCode !== 0) {
        throw new Error(`Unable to push docker image ${image}, ${subprocess.stderr}`);
    }
}
exports.dockerPush = dockerPush;
async function pgrep(name) {
    const result = await exec({ cmd: 'ps', args: ['aux'] }, false);
    if (!result) {
        throw new Error('Invalid result from ps aux');
    }
    const found = result.split('\n').find((line) => {
        if (!line)
            return false;
        return line.toLowerCase().includes(name.toLowerCase());
    });
    if (found) {
        logger.trace('found process', found);
        return found;
    }
    return '';
}
exports.pgrep = pgrep;
async function getCommitHash() {
    if (process.env.GIT_COMMIT_HASH)
        return process.env.GIT_COMMIT_HASH;
    return exec({ cmd: 'git', args: ['rev-parse', '--short', 'HEAD'] });
}
exports.getCommitHash = getCommitHash;
async function gitDiff(files = []) {
    try {
        await fork({ cmd: 'git', args: ['diff', ...files] });
    }
    catch (e) {
        process.exitCode = 0;
        logger.warn(e);
    }
}
exports.gitDiff = gitDiff;
async function getChangedFiles(...files) {
    try {
        const result = await exec({
            cmd: 'git', args: ['diff', '--name-only', ...files]
        });
        return result
            .split('\n')
            .map((str) => str.trim())
            .filter(Boolean);
    }
    catch (e) {
        // if there error includes ENOENT
        // we can just log the error and continue on
        if (e.toString().includes('ENOENT')) {
            process.exitCode = 0;
            logger.warn(e);
            return [];
        }
        throw e;
    }
}
exports.getChangedFiles = getChangedFiles;
function mapToArgs(input) {
    const args = [];
    for (const [key, value] of Object.entries(input)) {
        const vals = Array.isArray(value) ? value : [value];
        if (key.length > 1) {
            args.push(`--${key}`, ...vals);
        }
        else {
            args.push(`-${key}`, ...vals);
        }
    }
    return args.filter((str) => str != null && str !== '');
}
exports.mapToArgs = mapToArgs;
async function yarnPublish(pkgInfo, tag = 'latest', registry = config.NPM_DEFAULT_REGISTRY) {
    await fork({
        cmd: 'yarn',
        args: [
            'publish',
            '--non-interactive',
            '--new-version',
            pkgInfo.version,
            '--no-git-tag-version',
            '--registry',
            registry,
            '--tag',
            tag
        ],
        cwd: pkgInfo.dir,
        env: {
            NODE_ENV: 'production'
        }
    });
}
exports.yarnPublish = yarnPublish;
//# sourceMappingURL=scripts.js.map