codefresh 0.78.2

package/lib/interface/cli/Command.js

@@ -0,0 +1,331 @@
+const yargs = require('yargs');
+const CFError = require('cf-errors');
+const _ = require('lodash');
+const { wrapHandler } = require('./helpers/general');
+const Output = require('../../output/Output');
+const { sdk } = require('../../logic');
+
+
+class Command {
+    constructor(command) {
+        this.root = command.root;
+        delete command.root;
+
+        if (command.hasOwnProperty('requiresAuthentication')) {
+            this.requiresAuthentication = command.requiresAuthentication;
+        } else if (this.root) {
+            this.requiresAuthentication = true;
+        }
+
+        this.betaCommand = command.betaCommand || false;
+        this.onPremCommand = command.onPremCommand || false;
+
+        this.handler = command.handler;
+        this.command = command.command;
+        this.aliases = command.aliases || [];
+
+        this.webDocs = command.webDocs;
+        this.description = _.get(command, 'cliDocs.description', command.description || command.desc);
+        if (!this.description) {
+            throw new CFError(`description field is missing for command: ${JSON.stringify(command, 2, 4)}`);
+        }
+        if (!this.description.endsWith('.')) {
+            this.description += '.';
+        }
+
+        this.usage = command.usage || '';
+        // TODO uncomment this
+        // if (!this.usage) {
+        //     throw new CFError(`usage field is missing for command: ${JSON.stringify(command, 2, 4)}`);
+        // }
+        if (!this.usage.endsWith('.') && this.usage) {
+            this.usage += '.';
+        }
+
+        this.subCommands = [];
+        if (command.parent) {
+            this.setParentCommand(command.parent);
+        }
+
+        this.builders = [];
+        this.addBuilder(this._createUsageBuilder.bind(this));
+
+        if (_.isUndefined(command.handler)) {
+            command.handler = (args) => {
+                Output.printError(`Error: unknown command "${args._[args._.length - 1]}"\n` +
+                    'Run \'codefresh --help\' for usage.');
+            };
+        }
+        if (!_.isUndefined(command.builder)) {
+            this.addBuilder(command.builder);
+        }
+    }
+
+    _createBuilderFunction() {
+        const builder = (yargs) => {
+            _.forEach(this.builders, (builder) => {
+                builder(yargs);
+            });
+
+            _.forEach(this.subCommands, (subCommand) => {
+                if (!subCommand.hasOwnProperty('requiresAuthentication') && this.hasOwnProperty('requiresAuthentication')) {
+                    subCommand.requiresAuthentication = this.requiresAuthentication;
+                }
+
+                if (subCommand.isBetaCommand()) {
+                    // load beta commands only if authentication exists and it is beta enabled
+                    const currentContext = sdk.config && sdk.config.context;
+                    if (currentContext && currentContext.isBetaFeatEnabled()) {
+                        yargs.command(subCommand.toCommand());
+                    }
+                } else if (subCommand.isOnPremCommand()) {
+                    // load onPrem commands only if authentication exists and it is onPrem enabled
+                    const currentContext = sdk.config && sdk.config.context;
+                    if (currentContext && currentContext.isOnPremFeatEnabled()) {
+                        yargs.command(subCommand.toCommand());
+                    }
+                } else {
+                    yargs.command(subCommand.toCommand());
+                }
+            });
+            return yargs;
+        };
+
+        return builder;
+    }
+
+    _createUsageBuilder(yargs) {
+        let baseCommandPrefix = 'codefresh';
+
+        let parentCommand = this.getParentCommand();
+        while (parentCommand) {
+            baseCommandPrefix += ` ${parentCommand.command}`;
+            parentCommand = parentCommand.getParentCommand();
+        }
+
+        if (this.usage) {
+            yargs.usage(`Command: ${baseCommandPrefix} ${this.command}\n\nDescription:\n ${this.description}\n\n ${this.usage}`);
+        } else {
+            yargs.usage(`Command: ${baseCommandPrefix} ${this.command}\n\nDescription:\n ${this.description}`);
+        }
+    }
+
+    prepareDocs(parentCommandExists) {
+        const Mock = function () {
+            this.positionals = [];
+            this.options = [];
+
+            if (!parentCommandExists) {
+                this.options.push({
+                    key: 'help',
+                    value: {
+                        describe: 'Print help information',
+                    },
+                });
+            }
+
+            this.examples = [];
+            this.positional = (key, value) => {
+                const positional = {
+                    key,
+                    value,
+                };
+                if (res.command.includes(`<${key}>`)) {
+                    positional.value.required = true;
+                }
+                this.positionals.push(positional);
+                return this;
+            };
+            this.option = (key, value) => {
+                if (parentCommandExists && key === 'filename') {
+                    return this;
+                }
+                this.options.push({
+                    key,
+                    value,
+                });
+                return this;
+            };
+            this.example = (command, explanation) => {
+                this.examples.push({
+                    command,
+                    explanation,
+                });
+                return this;
+            };
+
+            for (var property in yargs) {
+                if (yargs.hasOwnProperty(property)) {
+                    if (typeof yargs[property] === 'function' && !this[property]) {
+                        this[property] = () => {
+                            return this;
+                        };
+                    }
+                }
+            }
+        };
+
+        const res = {};
+        res.command = [this.command];
+        _.forEach(this.aliases, (alias) => {
+            res.command.push(`${alias} ${this.command.substr(this.command.indexOf(" ") + 1)}`);
+        });
+        res.usage = this.usage.replace(/\n/g, '<br>');
+        res.usage = res.usage.replace(/\t/g, '<li>');
+        res.aliases = this.aliases;
+
+        const mock = new Mock();
+
+        const builderFunction = this._createBuilderFunction();
+        const { options, positionals, examples } = builderFunction(mock);
+
+        let parentCommandDocs;
+        if (this.getParentCommand()) {
+            parentCommandDocs = this.getParentCommand()
+                .prepareDocs(true);
+        }
+
+        if (parentCommandDocs) {
+            for (var i = 0; i < res.command.length; i++) {
+                res.command[i] = `${parentCommandDocs.command[0]} ${res.command[i]}`;
+            }
+
+        } else {
+            for (var i = 0; i < res.command.length; i++) {
+                res.command[i] = `codefresh ${res.command[i]}`;
+            }
+        }
+
+        const webDocs = this.webDocs;
+        if (webDocs) {
+            res.description = webDocs.description || this.description || '';
+            res.title = webDocs.title;
+            res.category = webDocs.category;
+            res.subCategory = webDocs.subCategory;
+            res.weight = webDocs.weight;
+            res.header = `+++\ntitle = "${res.title}"\n+++`;
+        }
+
+        res.positionals = parentCommandDocs ? parentCommandDocs.positionals || '' : '';
+        _.forEach(positionals, (positional) => {
+            const key = positional.key;
+            let description = positional.value.describe || positional.value.description;
+            if (positional.value.required) {
+                description += '. `required`';
+            }
+            if (positional.value.choices) {
+                let choicesString = '<br><br>Possible values:';
+                _.forEach(positional.value.choices, (choice) => {
+                    choicesString += `<br> - ${choice}`;
+                });
+                description += choicesString;
+            }
+            const defaultValue = positional.value.default || '';
+            const alias = positional.value.alias || '';
+            res.positionals += `${key} | ${alias} | ${defaultValue} | ${description}\n`;
+        });
+
+        res.options = _.get(parentCommandDocs, 'options', {});
+        _.forEach(options, (option) => {
+            if (option.value.omitFromDocs) {
+                return;
+            }
+            const group = option.value.group || 'Options';
+            res.options[group] = res.options[group] || '';
+            const key = option.key;
+            let description = option.value.describe || option.value.description;
+            if (option.value.required) {
+                description += '. `required`';
+            }
+            if (option.value.choices) {
+                let choicesString = '<br><br>Possible values:';
+                _.forEach(option.value.choices, (choice) => {
+                    choicesString += `<br> - ${choice}`;
+                });
+                description += choicesString;
+            }
+
+            let optionType = '';
+            if (option.value.type) {
+                if (typeof option.value.type === 'string') {
+                    optionType = option.value.type;
+                } else if (option.value.type === Array) {
+                    optionType = 'array';
+                }
+            } else if (option.value.default) {
+                const primitiveTypes = ['string', 'number', 'boolean'];
+                const defaultValueType = typeof option.value.default;
+                if (primitiveTypes.includes(defaultValueType)) {
+                    optionType = defaultValueType;
+                } else if (Array.isArray(option.value.default)) {
+                    optionType = 'array';
+                }
+            }
+
+            let aliases = '';
+            if (option.value.alias) {
+                if (_.size(option.value.alias) === 1) {
+                    aliases += `-${option.value.alias}`;
+                } else {
+                    aliases += `--${option.value.alias}`;
+                }
+            }
+            const defaultValue = option.value.default || (optionType === 'boolean' ? 'false' : '');
+            res.options[group] += `--${key} | ${aliases} | ${optionType} | ${defaultValue} | ${description}\n`;
+        });
+
+        res.examples = '';
+        _.forEach(examples, (example) => {
+            res.examples += `#### ${example.explanation}\n\n\`${example.command}\`\n`;
+        });
+
+        return res;
+    }
+
+    isRoot() {
+        return this.root;
+    }
+
+    isBetaCommand() {
+        return this.betaCommand;
+    }
+
+    isOnPremCommand() {
+        return this.onPremCommand;
+    }
+
+    addBuilder(b) {
+        this.builders.push(b);
+    }
+
+    subCommand(command) {
+        this.subCommands.push(command);
+        return this;
+    }
+
+    setParentCommand(parentCommand) {
+        this.parentCommand = parentCommand;
+        this.parentCommand.subCommand(this);
+        return this;
+    }
+
+    getParentCommand() {
+        return this.parentCommand;
+    }
+
+    toCommand() {
+        const yargsCommand = {};
+
+        yargsCommand.aliases = this.aliases;
+        yargsCommand.description = this.description;
+        yargsCommand.command = this.command;
+        yargsCommand.builder = this._createBuilderFunction();
+        yargsCommand.handler = wrapHandler(this.handler || (() => yargs.showHelp()), this.requiresAuthentication);
+        return yargsCommand;
+
+    }
+
+}
+
+
+module.exports = Command;

package/lib/interface/cli/codefresh

@@ -0,0 +1,24 @@
+#!/usr/bin/env node
+
+const Output = require('../../output/Output');
+
+process.on('uncaughtException', (err) => {
+    Output.printError(err);
+    process.exit(1);
+});
+
+process.on('unhandledRejection', (err) => {
+    Output.printError(err);
+    process.exit(1);
+});
+
+if (process.argv.includes('--get-yargs-completions')) {
+    const completionInterface = require('./completion');
+    completionInterface().argv; // eslint-disable-line
+} else {
+    const { startCommandLine } = require('./commad-line-interface');
+    startCommandLine().catch((err) => {
+        Output.printError(err);
+        process.exit(1);
+    });
+}

package/lib/interface/cli/commad-line-interface.js

@@ -0,0 +1,90 @@
+const _ = require('lodash');
+const yargs = require('yargs');
+const path = require('path');
+const recursive = require('recursive-readdir');
+
+const DEFAULTS = require('./defaults');
+const { Config } = require('codefresh-sdk');
+const { version } = require('../../../package.json');
+const configManager = require('../../logic/cli-config/Manager');
+const openapi = require('../../../openapi');
+const sdk = require('../../logic/sdk');
+const cliConfHelpers = require('./helpers/cli-config');
+
+const PROCESS_ARGV = require('yargs-parser')(process.argv);
+
+const cliConfig = configManager.config();
+
+async function getConfigForSdk() {
+    const configOptions = {
+        configPath: PROCESS_ARGV.cfconfig,
+        spec: { json: openapi },
+        request: _.defaultsDeep({
+            timeout: PROCESS_ARGV.requestTimeout,
+            headers: {
+                'User-Agent': `codefresh-cli-v${version}`,
+                'Codefresh-User-Agent-Type': 'cli',
+                'Codefresh-User-Agent-Version': version,
+            },
+        }, cliConfig.request, cliConfHelpers.getSdkConfigForPagination().request),
+    };
+    return Config.load(configOptions);
+}
+async function startCommandLine() {
+    const [files, config] = await Promise.all([
+        recursive(path.resolve(__dirname, 'commands')),
+        getConfigForSdk(),
+    ]);
+
+    sdk.configure(config);
+
+    const rootCommands = [];
+    _.forEach(files, (file) => {
+        if (file.endsWith('.cmd.js')) {
+            const command = require(file);
+            if (command.isRoot()) {
+                if (command.isBetaCommand()) {
+                    if (config && config.context && config.context.isBetaFeatEnabled()) {
+                        rootCommands.push(command);
+                    }
+                } else {
+                    rootCommands.push(command);
+                }
+            }
+        }
+    });
+    _.forEach(rootCommands, command => yargs.command(command.toCommand()));
+
+    return yargs // eslint-disable-line
+        .env('CF_ARG_') // this means that every process.env.CF_ARG_* will be passed to argv
+        .option('cfconfig', {
+            describe: `Custom path for authentication contexts config file (default: ${DEFAULTS.CFCONFIG})`,
+            global: false,
+        })
+        .option('insecure', {
+            describe: 'disable certificate validation for TLS connections (e.g. to g.codefresh.io)',
+            type: 'boolean',
+            coerce: (insecure) => {
+                if (insecure) {
+                    process.env.NODE_TLS_REJECT_UNAUTHORIZED = '0';
+                }
+                return insecure;
+            },
+        })
+        .option('request-timeout', {
+            describe: `Request timeout (default: ${cliConfig.request.timeout})`,
+            global: false,
+        })
+        .demandCommand(1, 'You need at least one command before moving on')
+        .parserConfiguration({
+            'boolean-negation': false,
+        })
+        .wrap(null)
+        .version(false)
+        .help('help')
+        .epilogue('For more information, find our official documentation at http://cli.codefresh.io')
+        .argv;
+}
+
+module.exports = { startCommandLine, getConfigForSdk };
+

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

@@ -0,0 +1,61 @@
+const Command = require('../../Command');
+const CFError = require('cf-errors');
+const { sdk } = require('../../../../logic');
+
+const applyRoot = require('../root/apply.cmd');
+const { ignoreHttpError } = require('../../helpers/general');
+
+const command = new Command({
+    command: 'agent [id|name]',
+    aliases: [],
+    parent: applyRoot,
+    description: 'Patch an agent',
+    webDocs: {
+        category: 'Agents',
+        title: 'Patch Agent',
+    },
+    builder: (yargs) => {
+        yargs
+            .positional('id|name', {
+                describe: 'agent id or name',
+            })
+            .option('newName', {
+                describe: 'New name',
+                alias: 'n',
+            })
+            .option('runtimes', {
+                array: true,
+                alias: 're',
+                describe: 'Agent runtimes',
+            })
+            .example(
+                'codefresh patch agent ID --name NEW_NAME',
+                'Replace agent name. Specifying agent by ID',
+            )
+            .example(
+                'codefresh patch agent NAME --re runtime1',
+                'Replace agent runtimes. Specifying agent by NAME',
+            );
+
+        return yargs;
+    },
+    handler: async (argv) => {
+        const { id, name } = argv;
+
+        const {
+            newName,
+            runtimes,
+        } = argv;
+
+        let agent = await sdk.agents.get({ agentId: id }).catch(ignoreHttpError);
+        agent = agent || await sdk.agents.getByName({ name }).catch(ignoreHttpError);
+        if (!agent) {
+            throw new CFError(`No such agent: "${name || id}"`);
+        }
+
+        await sdk.agents.update({ agentId: agent.id }, { name: newName, runtimes });
+        console.log(`Agent: "${name || id}" patched.`);
+    },
+});
+
+module.exports = command;

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

@@ -0,0 +1,39 @@
+const Command = require('../../Command');
+const { sdk } = require('../../../../logic');
+const createRoot = require('../root/create.cmd');
+
+
+const command = new Command({
+    command: 'agent <name>',
+    parent: createRoot,
+    description: 'Create an agent',
+    usage: 'Create an agent used to behind firewall integration.',
+    webDocs: {
+        category: 'Agents',
+        title: 'Create Agent',
+    },
+    builder: yargs => yargs
+        .positional('name', {
+            describe: 'Name of agent',
+        })
+        .option('runtimes', {
+            array: true,
+            alias: 'r',
+            describe: 'Agent runtimes',
+            default: [],
+        })
+        .example('codefresh create agent NAME', 'Create an agent')
+        .example('codefresh create agent NAME -r runtime1 -r runtime2', 'Create an agent with runtimes: [ "runtime1", "runtime2"]'),
+    handler: async (argv) => {
+        const {
+            name,
+            runtimes,
+        } = argv;
+
+        const agent = await sdk.agents.create({ name, runtimes });
+        console.log(`Agent: "${agent.name}" created`);
+        console.log(agent.token);
+    },
+});
+
+module.exports = command;

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

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

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

@@ -0,0 +1,44 @@
+const Command = require('../../Command');
+const { sdk } = require('../../../../logic');
+const Agent = require('../../../../logic/entities/Agent');
+const Output = require('../../../../output/Output');
+const _ = require('lodash');
+const { ignoreHttpError } = require('../../helpers/general');
+
+const getRoot = require('../root/get.cmd');
+
+const command = new Command({
+    command: 'agents [id|name]',
+    aliases: ['agent'],
+    parent: getRoot,
+    description: 'Get a specific agent or an array of agents',
+    webDocs: {
+        category: 'Agents',
+        title: 'Get Agents',
+    },
+    builder: yargs => yargs
+        .positional('id|name', {
+            describe: 'Agent id or name to get one agent',
+        })
+        .option('name', {
+            alias: 'n',
+            describe: 'Agent name to filter by',
+        }),
+    handler: async (argv) => {
+        const { id, name } = argv; // eslint-disable-line
+
+        let agents;
+        if (id) {
+            let agent = await sdk.agents.get({ agentId: id }).catch(ignoreHttpError);
+            agent = agent || await sdk.agents.getByName({ name }).catch(ignoreHttpError);
+            agents = agent ? [agent] : [];
+        } else {
+            agents = await sdk.agents.list({
+                name,
+            });
+        }
+        Output.print(_.map(agents, Agent.fromResponse));
+    },
+});
+
+module.exports = command;

package/lib/interface/cli/commands/agent/helper.js

@@ -0,0 +1,28 @@
+const sdk = require('../../../../logic/sdk');
+const _ = require('lodash');
+
+async function getNewAgentName(kubeContextName, kubeNamespace, agents) {
+    const defaultName = `${kubeContextName}_${kubeNamespace}`;
+    if (!agents) {
+        // eslint-disable-next-line no-param-reassign
+        agents = await sdk.agents.list({ });
+    }
+    let name;
+
+    if (!_.isArray(agents) || !_.find(agents, a => a.name === defaultName)) {
+        name = defaultName; // use the default name if there are no collisions
+    } else {
+        const agentsNames = new Set(_.map(agents, a => a.name)); // for fast lookup
+        let i = 1;
+        while (agentsNames.has(`${defaultName}_${i}`)) {
+            i += 1;
+        }
+        name = `${defaultName}_${i}`;
+    }
+
+    return name;
+}
+
+module.exports = {
+    getNewAgentName,
+};