codefresh 0.78.2

package/lib/interface/cli/commands/pipeline/run.cmd.js

@@ -0,0 +1,165 @@
+const debug = require('debug')('codefresh:cli:run:pipeline');
+const Command = require('../../Command');
+const { crudFilenameOption } = require('../../helpers/general');
+const RunLocalCommand = require('./run.local');
+const RunExternalCommand = require('./run.cf');
+
+function getCommandFlavor(argv) {
+    if (argv.local) {
+        return new RunLocalCommand(argv);
+    }
+    return new RunExternalCommand(argv);
+}
+
+const run = new Command({
+    root: true,
+    command: 'run [name]',
+    description: 'Run a pipeline by id or name and attach the created workflow logs.',
+    usage: 'Returns an exit code according to the workflow finish status (Success: 0, Error: 1, Terminated: 2)',
+    webDocs: {
+        category: 'Pipelines',
+        title: 'Run Pipeline',
+        weight: 50,
+    },
+    builder: (yargs) => {
+        yargs
+            .option('trigger', {
+                describe: 'Trigger id or name',
+                alias: 't',
+            })
+            .option('branch', {
+                describe: 'Branch',
+                alias: 'b',
+            })
+            .positional('name', {
+                describe: 'Pipeline name',
+            })
+            .option('memory', {
+                describe: 'Mention machine memory sizes during pipeline run',
+                coerce: value => `${value}Mi`,
+            })
+            .option('cpu', {
+                describe: 'Mention machine cpu sizes during pipeline run',
+                coerce: value => `${value}m`,
+            })
+            .option('disk', {
+                describe: 'Mention machine disk space sizes during pipeline run',
+                coerce: value => `${value}Gi`,
+            })
+            .option('pack-name', {
+                describe: 'Resources size (`small`, `medium` or `large`)',
+                choices: ['small', 'medium', 'large'],
+            })
+            .option('runtime-name', {
+                describe: 'Runtime environment for run pipeline',
+            })
+            .option('sha', {
+                describe: 'Set commit sha',
+                alias: 's',
+            })
+            .option('no-cache', {
+                describe: 'Ignore cached images',
+                alias: 'nc',
+                default: false,
+                type: 'boolean',
+            })
+            .option('annotation', {
+                describe: 'Add annotations to created build',
+                default: [],
+                alias: 'a',
+
+            })
+            .option('enable-notifications', {
+                describe: 'Report notifications about pipeline execution',
+                alias: 'en',
+                default: false,
+                type: 'boolean',
+            })
+            .option('reset-volume', {
+                describe: 'Reset pipeline cached volume',
+                alias: 'rv',
+                default: false,
+                type: 'boolean',
+            })
+            .option('variable', {
+                describe: 'Set build variables',
+                default: [],
+                alias: 'v',
+            })
+            .option('detach', {
+                alias: 'd',
+                describe: 'Run pipeline and print build ID',
+            })
+            .option('context', {
+                alias: 'c',
+                describe: 'Run pipeline with contexts',
+                default: [],
+                array: true,
+            })
+            .option('local', {
+                describe: 'Run pipeline on your local docker machine',
+                type: 'boolean',
+                default: false,
+            })
+            .option('local-volume', {
+                describe: 'Use your file system as volume in local run',
+                alias: 'lv',
+            })
+            .option('no-cf-cache', {
+                describe: 'Ignore Codefresh cache optimizations',
+                alias: 'ncfc',
+                default: false,
+                type: 'boolean',
+            })
+            .option('only', {
+                describe: 'run only specific steps',
+                array: true,
+            })
+            .option('skip', {
+                describe: 'skip specific steps',
+                array: true,
+            })
+            .option('debug', {
+                describe: 'debug mode',
+            })
+            .example('codefresh run PIPELINE_ID | PIPELINE_NAME --trigger TRIGGER_ID | TRIGGER_NAME -b=master', 'Choosing a specific trigger')
+            .example('codefresh run PIPELINE_ID | PIPELINE_NAME -b=master', 'Defining the source control context using a branch')
+            .example('codefresh run PIPELINE_ID | PIPELINE_NAME -s=52b992e783d2f84dd0123c70ac8623b4f0f938d1', 'Defining the source control context using a commit')
+            .example('codefresh run PIPELINE_ID | PIPELINE_NAME -b=master -v key1=value1 -v key2=value2', 'Setting variables through the command')
+            .example('codefresh run PIPELINE_ID | PIPELINE_NAME -b=master --var-file ./var_file.yml', 'Settings variables through a yml file')
+            .example('codefresh run PIPELINE_ID | PIPELINE_NAME -b=master --context context', 'Inject contexts to the pipeline execution')
+            .example('codefresh run PIPELINE_ID | PIPELINE_NAME --skip step1 step2 step3', 'Skip specific steps');
+
+        crudFilenameOption(yargs, {
+            name: 'variable-file',
+            alias: 'var-file',
+            describe: 'Set build variables from a file',
+        });
+
+        crudFilenameOption(yargs, {
+            name: 'yaml',
+            alias: 'y',
+            raw: true,
+            describe: 'Override codefresh.yaml for this execution',
+        });
+
+        return yargs;
+    },
+    handler: async (argv) => {
+        const exitProcess = (argv && argv.exitProcess);
+        const flavor = getCommandFlavor(argv);
+
+        if (argv && argv.returnWorkflowId) {
+            return flavor.run();
+        }
+
+        await flavor.preRunAll();
+        const exitCode = await flavor.run();
+        await flavor.postRunAll();
+        if (exitProcess !== false) {
+            process.exit(exitCode);
+        }
+    },
+});
+
+module.exports = run;

package/lib/interface/cli/commands/pipeline/run.completion.js

@@ -0,0 +1,15 @@
+const { handleOptions, fileDir } = require('../../completion/helpers');
+
+const FILENAME_OPTIONS = ['--variable-file', '--var-file', '--yaml', '-y'];
+
+function optionHandler({ word, argv, option }) {
+    if (FILENAME_OPTIONS.includes(option)) {
+        return fileDir(word);
+    }
+    return [];
+}
+
+module.exports = {
+    optionHandler: handleOptions([...FILENAME_OPTIONS], optionHandler),
+};
+

package/lib/interface/cli/commands/pipeline/run.local.js

@@ -0,0 +1,200 @@
+/* eslint-disable prefer-promise-reject-errors */
+const Docker = require('dockerode');
+const RunBaseCommand = require('./run.base');
+const path = require('path');
+const DEFAULTS = require('../../defaults');
+const _ = require('lodash');
+const { sdk } = require('../../../../logic');
+const { followLogs } = require('../../helpers/logs');
+const chalk = require('chalk');
+const { addProxyVariables, detectProxy } = require('../../helpers/general');
+
+const regex = /##[0-9a-f]{24}##/i;
+const EngineErrorPrefix = 'EngineError';
+
+
+function _customizer(objValue, srcValue) {
+    if (Array.isArray(objValue)) {
+        return _.compact(objValue.concat(srcValue));
+    }
+}
+
+const convertStatus = (json) => {
+    if (json.status === 'Pull complete') {
+        return `Pulled layer '${json.id}'\n`;
+    } else if (json.status.startsWith('Pulling from')) {
+        return `Pulling image ${json.status.slice(13)}:${json.id}\n`;
+    } else if (json.status === 'Already exists') {
+        return `Layer '${json.id}' already exists\n`;
+    } else if (json.id === undefined) {
+        return `${json.status}\n`;
+    }
+    return undefined;
+};
+
+class RunLocalCommand extends RunBaseCommand {
+    constructor(argv) {
+        super(argv);
+        this.docker = new Docker();
+    }
+    async preRunAll() {
+        await super.preRunAll();
+        console.log('Updating Codefresh engine ==>\n');
+        return new Promise((resolve, reject) => {
+            this.docker.pull(DEFAULTS.ENGINE_IMAGE, (err, stream) => {
+                if (err) {
+                    reject(err);
+                }
+                if (stream) {
+                    function onFinished(error) {
+                        if (error) {
+                            reject(error);
+                            return;
+                        }
+                        console.log('\nFinished Update ==>\n');
+                        resolve();
+                    }
+
+                    function onProgress(res) {
+                        if (_.get(res, 'status')) {
+                            const line = convertStatus(res);
+                            if (line) {
+                                process.stdout.write(line);
+                            }
+                        }
+                    }
+
+                    this.docker.modem.followProgress(stream, onFinished, onProgress);
+                }
+            });
+        });
+    }
+    async runImpl(request) {
+        const { pipelineName } = request;
+        const {
+            branch, userYamlDescriptor, variables, noCache, resetVolume, noCfCache, enableNotifications, trigger, debug,
+        } = request.options;
+        const localVolume = this.argv['local-volume'] === true ?
+            path.join(DEFAULTS.CODEFRESH_PATH, pipelineName) : this.argv['local-volume'];
+        const injectedOpts = {};
+        injectedOpts.Env = [];
+        // TODO : Move to per command's handler so each command will be handled in a seperate handler
+        if (userYamlDescriptor) {
+            injectedOpts.Env.push(`OVERRIDE_WORKFLOW_YAML=${userYamlDescriptor}`);
+        }
+        if (localVolume) {
+            injectedOpts.Env.push(`EXTERNAL_WORKSPACE=${localVolume}`);
+            console.log(`\nUsing ${localVolume} as a local volume.\n`);
+        }
+
+        if (variables) {
+            const envVars = Object.keys(variables).reduce((sum, key) => sum += `${key.trim()}=${variables[key]},`, '');
+            injectedOpts.Env.push(`VARIABLES=${envVars.slice(0, envVars.length - 1)}`);
+        }
+
+        if (noCache) {
+            injectedOpts.Env.push(`NO_CACHE=${noCache}`);
+        }
+
+        if (resetVolume) {
+            injectedOpts.Env.push(`RESET_VOLUME=${resetVolume}`);
+        }
+        if (noCfCache) {
+            injectedOpts.Env.push(`NO_CF_CACHE=${noCfCache}`);
+        }
+        if (enableNotifications) {
+            injectedOpts.Env.push(`ENABLE_NOTIFICATIONS=${enableNotifications}`);
+        }
+
+        if (trigger) {
+            injectedOpts.Env.push(`TRIGGER=${trigger}`);
+        }
+
+        const currentContext = sdk.config.context;
+        console.log(`Running pipeline: ${pipelineName}`);
+
+        return new Promise((resolve, reject) => {
+            const proxyEnv = detectProxy();
+            const env = [
+                ...(debug ? ['PIPELINE_DEBUG_MODE=true'] : []),
+                `ACCESS_TOKEN=${currentContext.token}`,
+                `PIPELINE_ID=${pipelineName}`,
+                `BRANCH=${branch}`,
+                `CF_HOST=${currentContext.url}`,
+                'DOCKER_SOCKET_PATH=/var/run/docker.sock',
+            ];
+            addProxyVariables(env, proxyEnv);
+            const eventEmitter = this.docker.run(DEFAULTS.ENGINE_IMAGE, [], undefined, _.mergeWith({
+                Env: env,
+                Hostconfig: {
+                    Binds: [
+                        '/var/run/docker.sock:/var/run/docker.sock',
+                    ],
+                },
+            }, injectedOpts, _customizer), (err, data) => {
+                if (err) {
+                    console.log(chalk.red(`Error when running pipeline : ${err}`));
+                    // eslint-disable-next-line prefer-promise-reject-errors
+                    return resolve(1);
+                }
+
+                resolve(0);
+            });
+            if (this.argv.detach) {
+                resolve(0);
+                return;
+            }
+            eventEmitter.on('stream', (stream) => {
+                stream.on('data', (chunk) => {
+                    const line = chunk.toString();
+                    if (line.indexOf(`error: ${EngineErrorPrefix}`) !== -1) {
+                        const error = JSON.parse(line.substring(
+                            line.indexOf(`error: ${EngineErrorPrefix}`) + `error: ${EngineErrorPrefix}`.length,
+                            line.lastIndexOf(EngineErrorPrefix),
+                        ));
+                        if (error.code || error.message) {
+                            console.log(chalk.red(`Error when running pipeline code: ${error.code} message: ${error.message}`));
+                        } else {
+                            console.log(chalk.red(`Error when running pipeline: ${error}`));
+                        }
+
+                        this.status = 'Error';
+                        resolve(1);
+                    }
+                    const include = line.match(regex);
+                    if (include) {
+                        const workflowId = include[0].substring(2, include[0].length - 2);
+                        followLogs(workflowId).then(resolve);
+                    }
+                });
+                stream.on('error', (err) => {
+                    if (err) {
+                        console.log(chalk.red(`Pipeline finished with error: ${err}`));
+                        this.status = 'Error';
+                    }
+                    // eslint-disable-next-line prefer-promise-reject-errors
+                    resolve(1);
+                });
+                stream.on('end', () => {
+                    if (this.status !== 'Error') {
+                        resolve(0);
+                    }
+                });
+            });
+        });
+    }
+
+    // eslint-disable-next-line class-methods-use-this
+    get isParalel() {
+        return false;
+    }
+    async postRunRequest() {
+        if (this.status === 'Error') {
+            console.log(chalk.red('Failed to execute the pipeline'));
+        } else {
+            console.log(chalk.green('Pipeline executed successfully'));
+        }
+    }
+}
+
+module.exports = RunLocalCommand;

package/lib/interface/cli/commands/project/apply.cmd.js

@@ -0,0 +1,92 @@
+const Command = require('../../Command');
+const CFError = require('cf-errors');
+const _ = require('lodash');
+const { sdk } = require('../../../../logic');
+
+const applyRoot = require('../root/apply.cmd');
+const { prepareKeyValueObjectsFromCLIEnvOption, ignoreHttpError } = require('../../helpers/general');
+
+const command = new Command({
+    command: 'project [id|name]',
+    aliases: [],
+    parent: applyRoot,
+    description: 'Patch a project',
+    webDocs: {
+        category: 'Projects',
+        title: 'Patch Project',
+    },
+    builder: (yargs) => {
+        yargs
+            .positional('id|name', {
+                describe: 'project id or name',
+            })
+            .option('newName', {
+                describe: 'New name',
+                alias: 'n',
+            })
+            .option('tag', {
+                array: true,
+                alias: 't',
+                describe: 'Project tags',
+            })
+            .option('variable', {
+                array: true,
+                alias: 'v',
+                describe: 'Project variables',
+                coerce: prepareKeyValueObjectsFromCLIEnvOption,
+            })
+            .option('encrypted', {
+                array: true,
+                alias: 'e',
+                describe: 'Variable names to encrypt',
+            })
+            .example(
+                'codefresh patch project ID --new-name NEW_NAME --tag test',
+                'Replace project name and tags. Specifying project by ID',
+            )
+            .example(
+                'codefresh patch project NAME -v test=test',
+                'Replace project variables. Specifying project by NAME',
+            );
+
+        return yargs;
+    },
+    handler: async (argv) => {
+        const { id, name } = argv;
+
+        const {
+            newName: projectName,
+            tag: tags,
+            variable: variables,
+            encrypted,
+        } = argv;
+
+        const variableMap = _.reduce(variables, (acc, v) => _.assign(acc, { [v.key]: v }), {});
+        _.forEach(encrypted, (varName) => {
+            const variable = variableMap[varName];
+            if (!variable) {
+                throw new CFError(`Variable is not provided: "${varName}"`);
+            }
+            variable.encrypted = true;
+        });
+
+        let project = await sdk.projects.get({ id }).catch(ignoreHttpError);
+        project = project || await sdk.projects.getByName({ name }).catch(ignoreHttpError);
+        if (!project) {
+            throw new CFError(`No such project: "${name || id}"`);
+        }
+
+        const { tags: existingTags, variables: existingVariables } = project;
+
+        const updatePayload = _.pickBy({
+            projectName,
+            tags: tags || existingTags,
+            variables: variables || existingVariables,
+        }, _.identity);
+
+        await sdk.projects.patch({ id: project.id }, updatePayload);
+        console.log(`Project: "${name || id}" patched.`);
+    },
+});
+
+module.exports = command;

package/lib/interface/cli/commands/project/create.cmd.js

@@ -0,0 +1,70 @@
+const Command = require('../../Command');
+const CFError = require('cf-errors');
+const _ = require('lodash');
+const { sdk } = require('../../../../logic');
+const createRoot = require('../root/create.cmd');
+const { checkOrProjectExists } = require('../../helpers/validation');
+const { prepareKeyValueObjectsFromCLIEnvOption } = require('../../helpers/general');
+
+const command = new Command({
+    command: 'project <name>',
+    parent: createRoot,
+    description: 'Create a project',
+    usage: 'Create a project specifying name unique for account.',
+    webDocs: {
+        category: 'Projects',
+        title: 'Create Project',
+    },
+    builder: (yargs) => {
+        return yargs
+            .positional('name', {
+                describe: 'Name of project',
+            })
+            .option('tag', {
+                array: true,
+                alias: 't',
+                describe: 'Project tags',
+                default: [],
+            })
+            .option('variable', {
+                array: true,
+                alias: 'v',
+                describe: 'Project variables',
+                default: [],
+                coerce: prepareKeyValueObjectsFromCLIEnvOption,
+            })
+            .option('encrypted', {
+                array: true,
+                alias: 'e',
+                describe: 'Variable names to encrypt',
+                default: [],
+            })
+            .example('codefresh create project NAME', 'Create a project')
+            .example('codefresh create project NAME -t test -t run', 'Create a project with tags: [ "test", "run"]')
+            .example('codefresh create project NAME -v test=true -v run=false', 'Create a project with specific variables')
+            .example('codefresh create project NAME -v secret=secret -e secret', 'Create a project with encrypted variables');
+    },
+    handler: async (argv) => {
+        const {
+            name: projectName,
+            tag: tags,
+            variable: variables,
+            encrypted,
+        } = argv;
+
+        const variableMap = _.reduce(variables, (acc, v) => _.assign(acc, { [v.key]: v }), {});
+        _.forEach(encrypted, (varName) => {
+            const variable = variableMap[varName];
+            if (!variable) {
+                throw new CFError(`Variable is not provided: "${varName}"`);
+            }
+            variable.encrypted = true;
+        });
+
+        await checkOrProjectExists(projectName);
+        await sdk.projects.create({ projectName, tags, variables });
+        console.log(`Project: "${projectName}" created`);
+    },
+});
+
+module.exports = command;

package/lib/interface/cli/commands/project/delete.cmd.js

@@ -0,0 +1,39 @@
+const Command = require('../../Command');
+const CFError = require('cf-errors');
+const { sdk } = require('../../../../logic');
+const deleteRoot = require('../root/delete.cmd');
+const { ignoreHttpError } = require('../../helpers/general');
+
+const command = new Command({
+    command: 'project <id|name>',
+    aliases: [],
+    parent: deleteRoot,
+    description: 'Delete a project',
+    webDocs: {
+        category: 'Projects',
+        title: 'Delete Project',
+    },
+    builder: (yargs) => {
+        yargs
+            .positional('id|name', {
+                describe: 'project id or name',
+            })
+            .example('codefresh delete project NAME', 'Delete project by name.')
+            .example('codefresh delete project ID', 'Delete project by Id.');
+        return yargs;
+    },
+    handler: async (argv) => {
+        const { id, name } = argv;
+
+        let project = await sdk.projects.get({ id }).catch(ignoreHttpError);
+        project = project || await sdk.projects.getByName({ name }).catch(ignoreHttpError);
+        if (!project) {
+            throw new CFError(`No such project: "${name || id}"`);
+        }
+
+        await sdk.projects.delete({ id: project.id });
+        console.log(`Project '${name || id}' deleted.`);
+    },
+});
+
+module.exports = command;

package/lib/interface/cli/commands/project/get.cmd.js

@@ -0,0 +1,67 @@
+const Command = require('../../Command');
+const CFError = require('cf-errors');
+const { sdk } = require('../../../../logic');
+const Project = require('../../../../logic/entities/Project');
+const Output = require('../../../../output/Output');
+const _ = require('lodash');
+const DEFAULTS = require('../../defaults');
+const { ignoreHttpError } = require('../../helpers/general');
+
+const getRoot = require('../root/get.cmd');
+
+const command = new Command({
+    command: 'projects [id|name]',
+    aliases: ['project'],
+    parent: getRoot,
+    description: 'Get a specific project or an array of projects',
+    webDocs: {
+        category: 'Projects',
+        title: 'Get Projects',
+    },
+    builder: yargs => yargs
+        .positional('id|name', {
+            describe: 'Project id or name to get one project',
+        })
+        .option('name', {
+            alias: 'n',
+            describe: 'Project name to filter by',
+        })
+        .option('tag', {
+            alias: 't',
+            describe: 'Project tags array to filter by',
+            array: true,
+        })
+        .option('limit', {
+            describe: 'Limit amount of returned results',
+            default: DEFAULTS.GET_LIMIT_RESULTS,
+        })
+        .option('page', {
+            describe: 'Paginated page',
+            default: DEFAULTS.GET_PAGINATED_PAGE,
+        }),
+    handler: async (argv) => {
+        const { id, name, limit, page, tag: tags } = argv; // eslint-disable-line
+        const offset = (page - 1) * limit;
+
+        let projects;
+        if (id) {
+            let project = await sdk.projects.get({ id }).catch(ignoreHttpError);
+            project = project || await sdk.projects.getByName({ name, tags }).catch(ignoreHttpError);
+            projects = project ? [project] : [];
+        } else {
+            const result = await sdk.projects.list({
+                name,
+                tags,
+                limit,
+                offset,
+            });
+            projects = result.projects || []; // eslint-disable-line
+        }
+        if (!projects.length) {
+            throw new CFError('No projects found');
+        }
+        Output.print(_.map(projects, Project.fromResponse));
+    },
+});
+
+module.exports = command;