codefresh 0.78.2

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

@@ -0,0 +1,85 @@
+const Command = require('../../Command');
+const createRoot = require('../root/create.cmd');
+const { sdk } = require('../../../../logic');
+const { downloadSteveDore } = require('../hybrid/helper');
+const { Runner, components } = require('../../../../binary');
+
+const command = new Command({
+    command: 'clusters [name]',
+    aliases: ['cluster'],
+    parent: createRoot,
+    description: 'Create a cluster',
+    webDocs: {
+        category: 'Clusters',
+        title: 'Create Cluster',
+        weight: 100,
+    },
+    builder: yargs => yargs
+        .option('kube-context', {
+            describe: ' kubectl context name',
+            alias: 'kc',
+            required: true,
+        })
+        .option('namespace', {
+            describe: 'Kubernetes namespace to use while looking for service account',
+            alias: 'ns',
+            default: 'default',
+            required: true,
+        })
+        .option('serviceaccount', {
+            describe: 'Kubernetes serviceaccount credentials to be added to Codefresh',
+            alias: 'sa',
+            default: 'default',
+            required: true,
+        })
+        .option('behind-firewall', {
+            describe: 'Specify if the cluster is set behind a firewall',
+            default: false,
+            type: 'boolean',
+        })
+        .example('codefresh create cluster --kube-context production', 'Creating a cluster in codefresh'),
+    handler: async (argv) => {
+        const { context } = sdk.config;
+        const {
+            namespace,
+            serviceaccount,
+            'kube-context': contextName,
+            'behind-firewall': behindFirewall,
+            'bypass-download': bypassDownload,
+            name,
+        } = argv;
+        let {
+            terminateProcess,
+        } = argv;
+        if (terminateProcess === undefined) {
+            terminateProcess = true;
+        }
+        const binLocation = await downloadSteveDore(undefined, bypassDownload);
+        const componentRunner = new Runner(binLocation);
+        const commands = [
+            'create',
+            '--c',
+            contextName,
+            '--token',
+            context.token,
+            '--api-host',
+            `${context.url}/`,
+            '--namespace',
+            namespace,
+            '--serviceaccount',
+            serviceaccount,
+        ];
+        if (name) {
+            commands.push('--name-overwrite');
+            commands.push(name);
+        }
+        if (behindFirewall) {
+            commands.push('--behind-firewall');
+        }
+
+        await componentRunner.run(components.stevedore, commands);
+    },
+});
+
+
+module.exports = command;

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

@@ -0,0 +1,39 @@
+const Command = require('../../Command');
+const deleteRoot = require('../root/delete.cmd');
+const { sdk } = require('../../../../logic');
+const CFError = require('cf-errors');
+const _ = require('lodash');
+
+const command = new Command({
+    command: 'cluster <name>',
+    aliases: ['clusters'],
+    description: 'Delete a cluster',
+    parent: deleteRoot,
+    webDocs: {
+        category: 'Clusters',
+        title: 'Delete Cluster',
+    },
+    builder: (yargs) => {
+        return yargs
+            .positional('name', {
+                describe: 'Cluster name',
+                required: true,
+            })
+            .example('codefresh delete cluster NAME', 'Delete cluster NAME');
+    },
+    handler: async (argv) => {
+        const clusters = await sdk.clusters.list();
+        const cluster = _.find(clusters, (curr) => {
+            return _.isEqual(curr.selector, argv.name);
+        });
+
+        if (!cluster) {
+            throw new CFError(`No such cluster: ${argv.name}`);
+        }
+
+        await sdk.clusters.delete({ id: cluster._id, provider: cluster.provider });
+        console.log(`Cluster: '${argv.name}' deleted`);
+    },
+});
+
+module.exports = command;

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

@@ -0,0 +1,30 @@
+const _ = require('lodash');
+const Command = require('../../Command');
+const Output = require('../../../../output/Output');
+const getRoot = require('../root/get.cmd');
+const { sdk } = require('../../../../logic');
+const Cluster = require('../../../../logic/entities/Cluster');
+
+
+const command = new Command({
+    command: 'clusters',
+    aliases: ['cluster'],
+    category: 'Clusters',
+    parent: getRoot,
+    description: 'Get an array of clusters',
+    webDocs: {
+        category: 'Clusters',
+        title: 'Get Clusters',
+    },
+    builder: (yargs) => {
+        return yargs
+            .example('codefresh get clusters', 'Get all clusters');
+    },
+    handler: async (argv) => {
+        const clusters = await sdk.clusters.list();
+        Output.print(_.map(clusters, Cluster.fromResponse));
+    },
+});
+
+module.exports = command;
+

package/lib/interface/cli/commands/completion/bash.sh.hbs

@@ -0,0 +1,27 @@
+###-begin-{{app_name}}-completions-###
+#
+# codefresh command completion script
+#
+# Installation: {{app_path}} {{completion_command}} >> ~/.bashrc
+#    or {{app_path}} {{completion_command}} >> ~/.bash_profile on OSX.
+#
+_codefresh_completions()
+{
+    local cur args type_list
+
+    cur="${COMP_WORDS[COMP_CWORD]}"
+    args=("${COMP_WORDS[@]}")
+
+    # ask codefresh to generate completions.
+    type_list=$(codefresh --get-yargs-completions "${args[@]}")
+
+    if [[ ${type_list} == '__files_completion__' ]]; then
+        _filedir "@(yaml|yml|json)"
+    else
+        COMPREPLY=( $(compgen -W "${type_list}" -- ${cur}) )
+    fi
+
+    return 0
+}
+complete -F _codefresh_completions {{app_name}}
+###-end-{{app_name}}-completions-###

package/lib/interface/cli/commands/completion/completion.cmd.js

@@ -0,0 +1,66 @@
+const yargs = require('yargs');
+const Command = require('../../Command');
+const path = require('path');
+const fs = require('fs');
+
+/**
+ * yargs script generation file redone
+ * */
+function _generateCompletionScript(appPath, appName, completionCommand, shell) {
+    let script = fs.readFileSync(
+        path.resolve(__dirname, `${shell}.sh.hbs`),
+        'utf-8',
+    );
+    const name = appName || path.basename(appPath);
+
+    script = script.replace(/{{app_name}}/g, name);
+    script = script.replace(/{{completion_command}}/g, completionCommand);
+    return script.replace(/{{app_path}}/g, appPath);
+}
+
+const command = new Command({
+    root: true,
+    command: 'completion [shell-name]',
+    requiresAuthentication: false,
+    aliases: ['completions'],
+    description: 'Generate codefresh completion',
+    usage: 'Prints completion script with specified or default path to executable and command alias',
+    webDocs: {
+        category: 'Completion',
+        title: 'Codefresh Completion',
+        description: 'Generate codefresh completion. See details on [usage](codefresh-completion)',
+        weight: 30,
+    },
+    builder: (yargs) => {
+        return yargs
+            .positional('shellName', {
+                description: 'Name of the shell to generate completion for',
+                choices: ['bash', 'zsh'],
+                default: 'bash',
+            })
+            .option('executable', {
+                alias: 'e',
+                description: 'Name or path to your codefresh executable (default same as alias)',
+            })
+            .option('alias', {
+                alias: 'a',
+                description: 'Alias used for calling codefresh executable',
+                default: 'codefresh',
+            })
+            .example('codefresh completion', 'Print bash completion script')
+            .example('codefresh completion zsh', 'Print zsh completion script')
+            .example('codefresh completion zsh >> ~/.zshrc', 'Install zsh completion script')
+            .example('codefresh completion bash >> ~/.bashrc', 'Install bash completion script')
+            .example('codefresh completion bash >> ~/.bash_profile', 'Install bash completion script (on OSX)')
+            .example('cf completion --alias cf', 'Print completion script for codefresh aliased as "cf"')
+            .example('/some/path/codefresh completion -e /some/path/codefresh', 'Print completion script with specified path to codefresh executable');
+    },
+    handler: async (argv) => {
+        const { executable, alias: appName, shellName } = argv;
+        const appPath = executable || appName;
+        const script = _generateCompletionScript(appPath, appName, 'completion', shellName);
+        console.log(script);
+    },
+});
+
+module.exports = command;

package/lib/interface/cli/commands/completion/zsh.sh.hbs

@@ -0,0 +1,20 @@
+###-begin-{{app_name}}-completions-###
+#
+# codefresh command completion script
+#
+# Installation: {{app_name}} {{completion_command}} zsh >> ~/.zshrc
+#
+_codefresh_completions()
+{
+    type_list=($({{app_path}} --impl-zsh-file-dir --get-yargs-completions "${words[@]}"))
+
+    if [[ ${type_list[1]} == '__files_completion__' ]]; then
+        compadd -- "${type_list[@]:1}"
+    else
+        compadd -- "${type_list[@]}"
+    fi
+
+    return 0
+}
+compdef _codefresh_completions {{app_name}}
+###-end-{{app_name}}-completions-###

package/lib/interface/cli/commands/components/update.cmd.js

@@ -0,0 +1,30 @@
+const Command = require('../../Command');
+const componentsRoot = require('../root/components.cmd');
+const helper = require('../hybrid/helper');
+
+const command = new Command({
+    command: 'update',
+    parent: componentsRoot,
+    description: 'Update Codefresh CLI components',
+    webDocs: {
+        category: 'Components',
+        title: 'Update',
+    },
+    builder: yargs => yargs
+        .env('CF_ARG_') // this means that every process.env.CF_ARG_* will be passed to argv
+        .option('location', {
+            describe: 'Override download folder location',
+        })
+        .option('bypass-download', {
+            describe: 'Will bypass the attempt to download the installer. Instead, will immediately attempt to use the binary from the components folder',
+            default: false,
+            type: 'boolean',
+        }),
+    handler: async (argv) => {
+        console.log('Updating components');
+        const { location, bypassDownload } = argv;
+        await helper.downloadRelatedComponents(location, bypassDownload);
+    },
+});
+
+module.exports = command;

package/lib/interface/cli/commands/composition/composition.sdk.spec.js

@@ -0,0 +1,95 @@
+const getCmd = require('./get.cmd').toCommand();
+const deleteCmd = require('./delete.cmd').toCommand();
+const createCmd = require('./create.cmd').toCommand();
+const replaceCmd = require('./replace.cmd').toCommand();
+
+const request = require('requestretry');
+
+jest.mock('../../../../logic/entities/Composition');
+
+
+const DEFAULT_RESPONSE = request.__defaultResponse();
+
+describe('composition commands', () => {
+    beforeEach(async () => {
+        request.__reset();
+        request.mockClear();
+        await configureSdk(); // eslint-disable-line
+    });
+
+    describe('get', () => {
+        it('should handle getting given id', async () => {
+            const argv = { id: ['some id'] };
+            await getCmd.handler(argv);
+            await verifyResponsesReturned([DEFAULT_RESPONSE]); // eslint-disable-line
+        });
+
+        it('should handle getting all', async () => {
+            const argv = {};
+            const response = { statusCode: 200, body: [DEFAULT_RESPONSE.body] };
+            request.__setResponse(response);
+            await getCmd.handler(argv);
+            await verifyResponsesReturned([response]); // eslint-disable-line
+        });
+    });
+
+    describe('create', () => {
+        it('should handle creation', async () => {
+            const argv = { name: 'some name', variable: [] };
+            await createCmd.handler(argv);
+            await verifyResponsesReturned([DEFAULT_RESPONSE]); // eslint-disable-line
+        });
+
+        it('should throw on missing name', async () => {
+            const argv = { variable: [] };
+            await expect(createCmd.handler(argv)).rejects.toThrow();
+        });
+    });
+
+    describe('replace', () => {
+        it('should throw on missing name', async () => {
+            const argv = { variable: [] };
+            await expect(replaceCmd.handler(argv)).rejects.toThrow();
+        });
+
+        it('should handle replacing by name', async () => {
+            const argv = { name: 'some name', variable: [] };
+            const responses = [
+                { statusCode: 200, body: { _id: 'some id' } },
+                DEFAULT_RESPONSE,
+            ];
+            request.__queueResponses(responses);
+            await replaceCmd.handler(argv);
+            await verifyResponsesReturned(responses); // eslint-disable-line
+        });
+
+        it('should throw on composition not found', async () => {
+            const argv = { name: 'some name', variable: [] };
+            const response = { statusCode: 200, body: null };
+            request.__setResponse(response);
+            await expect(replaceCmd.handler(argv)).rejects.toThrow();
+            await verifyResponsesReturned([response]); // eslint-disable-line
+        });
+    });
+
+    describe('delete', () => {
+        it('should handle deletion given name', async () => {
+            const argv = { name: 'some name' };
+            const responses = [
+                { statusCode: 200, body: { _id: 'some id' } },
+                DEFAULT_RESPONSE,
+            ];
+            request.__queueResponses(responses);
+            await deleteCmd.handler(argv);
+            await verifyResponsesReturned(responses); // eslint-disable-line
+        });
+
+        it('should throw on composition not found', async () => {
+            const argv = { name: 'some name', variable: [] };
+            const response = { statusCode: 200, body: null };
+            request.__setResponse(response);
+            await expect(deleteCmd.handler(argv)).rejects.toThrow();
+            await verifyResponsesReturned([response]); // eslint-disable-line
+        });
+    });
+});

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

@@ -0,0 +1,67 @@
+const Command = require('../../Command');
+const CFError = require('cf-errors');
+const _ = require('lodash');
+const { prepareKeyValueObjectsFromCLIEnvOption } = require('../../helpers/general');
+const createRoot = require('../root/create.cmd');
+const { crudFilenameOption } = require('../../helpers/general');
+const { sdk } = require('../../../../logic');
+
+
+const command = new Command({
+    command: 'composition <name>',
+    aliases: ['com'],
+    parent: createRoot,
+    description: 'Create a composition',
+    webDocs: {
+        category: 'Compositions',
+        title: 'Create Composition',
+    },
+    builder: (yargs) => {
+        crudFilenameOption(yargs);
+        crudFilenameOption(yargs, {
+            name: 'compose-file',
+            describe: 'Path to docker-compose.yaml file to use to create the resource',
+            alias: 'c',
+            required: true,
+            raw: true,
+        });
+        return yargs
+            .positional('name', {
+                describe: 'Name of composition',
+            })
+            .option('variable', {
+                describe: 'Variables list',
+                default: [],
+                alias: 'v',
+            })
+            .option('advanced', {
+                describe: 'Advanced composition',
+                default: false,
+                type: 'boolean',
+                alias: 'a',
+            })
+            .example('codefresh create composition NAME --compose-file ./docker-compose.yml', 'Creating a composition using a docker-compose.yml file')
+            .example('codefresh create composition NAME --compose-file ./docker-compose.yml -v key1=value1 -v key2=value2', 'Defining composition variables');
+
+    },
+    handler: async (argv) => {
+        const data = argv.filename || {
+            name: argv.name,
+            vars: prepareKeyValueObjectsFromCLIEnvOption(argv.variable),
+            yamlJson: argv['compose-file'],
+            isAdvanced: argv.advanced,
+        };
+
+        const name = _.get(data, 'name');
+
+        if (!name) {
+            throw new CFError('Missing name of the composition');
+        }
+
+        await sdk.compositions.create(data);
+        console.log(`Composition: '${data.name}' created`);
+    },
+});
+
+
+module.exports = command;

package/lib/interface/cli/commands/composition/create.completion.js

@@ -0,0 +1,15 @@
+const { handleOptions, fileDir } = require('../../completion/helpers');
+
+const FILENAME_OPTIONS = ['--filename', '-f', '--compose-file', '-c'];
+
+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/composition/delete.cmd.js

@@ -0,0 +1,40 @@
+const Command = require('../../Command');
+const CFError = require('cf-errors');
+const _ = require('lodash');
+const deleteRoot = require('../root/delete.cmd');
+const { crudFilenameOption } = require('../../helpers/general');
+const { sdk } = require('../../../../logic');
+
+
+const command = new Command({
+    command: 'composition <name>',
+    aliases: ['com'],
+    parent: deleteRoot,
+    description: 'Delete a composition',
+    webDocs: {
+        category: 'Compositions',
+        title: 'Delete Composition',
+    },
+    builder: (yargs) => {
+        crudFilenameOption(yargs);
+        return yargs
+            .positional('name', {
+                describe: 'Composition name',
+            })
+            .example('codefresh delete composition NAME', 'Delete a composition');
+    },
+    handler: async (argv) => {
+        const name = (argv.filename) ? _.get(argv.filename, 'name') : argv.name;
+        const currComposition = await sdk.compositions.get({ id: name });
+        const id = currComposition ? currComposition._id : null;
+        if (!id) {
+            throw new CFError(`Cannot found composition: '${name}'`);
+        }
+        await sdk.compositions.delete({ id });
+        console.log(`Composition: '${name}' deleted`);
+    },
+});
+
+
+module.exports = command;
+

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

@@ -0,0 +1,43 @@
+const Command = require('../../Command');
+const _ = require('lodash');
+const Output = require('../../../../output/Output');
+const getRoot = require('../root/get.cmd');
+const Promise = require('bluebird');
+const { sdk } = require('../../../../logic');
+const Composition = require('../../../../logic/entities/Composition');
+
+const command = new Command({
+    command: 'compositions [id|name..]',
+    aliases: ['com', 'composition'],
+    parent: getRoot,
+    description: 'Get a specific composition or an array of compositions',
+    usage: 'Passing [id|name] argument will cause a retrieval of a specific composition.\n In case of not passing [id|name] argument, a list will be returned',
+    webDocs: {
+        category: 'Compositions',
+        title: 'Get Composition',
+    },
+    builder: (yargs) => {
+        return yargs
+            .positional('id', {
+                describe: 'composition id or name',
+            })
+            .example('codefresh get compositions', 'Get all compositions')
+            .example('codefresh get compositions NAME', 'Get a specific composition');
+    },
+    handler: async (argv) => {
+        const compositionIds = argv.id;
+
+        let compositions = [];
+        // TODO:need to decide for one way for error handeling
+        if (!_.isEmpty(compositionIds)) {
+            compositions = await Promise.map(compositionIds, id => sdk.compositions.get({ id }));
+        } else {
+            compositions = await sdk.compositions.list();
+        }
+        Output.print(_.map(compositions, Composition.fromResponse));
+    },
+});
+
+
+module.exports = command;
+

package/lib/interface/cli/commands/composition/replace.cmd.js

@@ -0,0 +1,76 @@
+const Command = require('../../Command');
+const CFError = require('cf-errors');
+const _ = require('lodash');
+const replaceRoot = require('../root/replace.cmd');
+const { crudFilenameOption } = require('../../helpers/general');
+const { sdk } = require('../../../../logic');
+const { prepareKeyValueObjectsFromCLIEnvOption } = require('../../helpers/general');
+
+
+const command = new Command({
+    command: 'composition [name]',
+    aliases: ['com'],
+    parent: replaceRoot,
+    description: 'Replace a composition resource',
+    webDocs: {
+        category: 'Compositions',
+        title: 'Replace Composition',
+    },
+    builder: (yargs) => {
+        crudFilenameOption(yargs);
+        crudFilenameOption(yargs, {
+            name: 'compose-file',
+            describe: 'Path to docker-compose.yaml file to use to create the resource',
+            alias: 'c',
+            required: true,
+            raw: true,
+        });
+        return yargs
+            .positional('name', {
+                describe: 'Name of composition',
+            })
+            .option('variable', {
+                describe: 'Variables list',
+                default: [],
+                alias: 'v',
+            })
+            .option('advanced', {
+                describe: 'Advanced composition',
+                default: false,
+                type: 'boolean',
+                alias: 'a',
+            })
+            .example('codefresh replace composition -f ./composition-spec.yml', 'Replace a composition using a spec file')
+            .example('codefresh replace composition NAME --compose-file ./docker-compose.yml -v key1=value1 -v key2=value2', 'Replace a composition using options');
+    },
+    handler: async (argv) => {
+        const data = argv.filename || {
+            name: argv.name,
+            vars: prepareKeyValueObjectsFromCLIEnvOption(argv.variable),
+            yamlJson: argv['compose-file'],
+            isAdvanced: argv.advanced,
+        };
+        const name = _.get(data, 'name');
+        let id;
+
+        if (!name) {
+            throw new CFError('Missing name of the composition');
+        }
+
+        const currComposition = await sdk.compositions.get({ id: name });
+        if (currComposition) {
+            id = currComposition._id;
+        }
+        if (!id) {
+            throw new CFError(`Cannot find composition: ${name}`);
+        }
+
+        await sdk.compositions.update({ id }, data);
+
+        console.log(`Composition: '${name}' replaced`);
+    },
+});
+
+
+module.exports = command;
+

package/lib/interface/cli/commands/composition/replace.completion.js

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