codefresh 0.78.2

package/lib/interface/cli/commands/helm/release/rollback-release.cmd.js

@@ -0,0 +1,87 @@
+const Command = require('../../../Command');
+const { sdk } = require('../../../../../logic');
+const { followLogs } = require('../../../helpers/logs');
+const Output = require('../../../../../output/Output');
+const helmUtil = require('./util');
+
+const rollback = new Command({
+    root: true,
+    command: 'rollback-release <name>',
+    description: 'Rollback a helm release from a kubernetes cluster',
+    webDocs: {
+        category: 'Predefined Pipelines',
+        title: 'Rollback Helm Release',
+        weight: 10,
+    },
+    builder: (yargs) => {
+        return yargs
+            .option('cluster', {
+                description: 'Run on cluster',
+                type: 'string',
+                required: true,
+                alias: 'c',
+            })
+            .option('revision', {
+                description: 'revision number',
+                type: 'number',
+                alias: 't',
+                required: true,
+            })
+            .option('tiller-namespace', {
+                description: 'prevent hooks from running during deletion',
+                type: 'string',
+                alias: 'n',
+                default: 'kube-system',
+            })
+            .option('namespace', {
+                description: 'prevent hooks from running during deletion',
+                type: 'string',
+                alias: 'ns',
+                default: 'default',
+            })
+            .option('detach', {
+                alias: 'd',
+                describe: 'Run pipeline and print build ID',
+            })
+            .example('codefresh rollback my-release --cluster my-cluster --revision 1',
+                'rollback release "my-release" from cluster "my-cluster"');
+    },
+    handler: async (argv) => {
+        const {
+            name: releaseName,
+            revision,
+            cluster: selector,
+            tillerNamespace,
+            namespace,
+        } = argv;
+
+        if (!releaseName) {
+            throw new Error('Release name is required');
+        }
+
+        try {
+            const ns = (await helmUtil.isHelm3(selector)) ? namespace : tillerNamespace;
+
+            const result = await sdk.kubernetes.rollback({
+                release: releaseName,
+                selector,
+                tillerNamespace: ns,
+                revision,
+            });
+
+            const workflowId = result.id;
+
+            if (argv.detach) {
+                console.log(workflowId);
+                return;
+            }
+            const exitCode = await followLogs(workflowId);
+            process.exit(exitCode);
+        } catch (err) {
+            Output.printError(err);
+            process.exit(1);
+        }
+    },
+});
+
+module.exports = rollback;

package/lib/interface/cli/commands/helm/release/test-release.cmd.js

@@ -0,0 +1,93 @@
+const Command = require('../../../Command');
+const { followLogs } = require('../../../helpers/logs');
+const { sdk } = require('../../../../../logic');
+const Output = require('../../../../../output/Output');
+const helmUtil = require('./util');
+
+const install = new Command({
+    root: true,
+    command: 'test-release <name>',
+    description: 'Test a helm release',
+    webDocs: {
+        category: 'Predefined Pipelines',
+        title: 'Test Helm Release',
+        weight: 30,
+    },
+    builder: (yargs) => {
+        return yargs
+            .positional('name', {
+                description: 'Release name',
+                type: 'string',
+                required: true,
+            })
+            .option('cluster', {
+                description: 'Run on cluster',
+                type: 'string',
+                required: true,
+            })
+            .option('tiller-namespace', {
+                description: 'namespace where is tiller running ( helm 2 only )',
+                type: 'string',
+                alias: 'n',
+                default: 'kube-system',
+            })
+            .option('namespace', {
+                description: 'namespace where is chart located ( helm 3 )',
+                type: 'string',
+                alias: 'ns',
+                default: 'default',
+            })
+            .option('timeout', {
+                description: 'time in seconds to wait for any individual kubernetes operation (like Jobs for hooks) (default 300)',
+                default: '300',
+                type: 'number',
+            })
+            .option('detach', {
+                alias: 'd',
+                describe: 'Run pipeline and print build ID',
+            })
+            .option('cleanup', {
+                description: 'delete test pods upon completion (default false)',
+                default: false,
+                type: 'boolean',
+            });
+    },
+    handler: async (argv) => {
+        const {
+            name: releaseName,
+            cluster,
+            cleanup,
+            timeout,
+            'tiller-namespace': tillerNamespace,
+            namespace,
+        } = argv;
+        if (!releaseName) {
+            throw new Error('Release name is required');
+        }
+        try {
+            const ns = (await helmUtil.isHelm3(cluster)) ? namespace : tillerNamespace;
+
+            const result = await sdk.helm.releases.test({
+                releaseName,
+                selector: cluster,
+                tillerNamespace: ns,
+            }, {
+                cleanup,
+                timeout,
+            });
+            const workflowId = result.id;
+
+            if (argv.detach) {
+                console.log(workflowId);
+                return;
+            }
+            const exitCode = await followLogs(workflowId);
+            process.exit(exitCode);
+        } catch (err) {
+            Output.printError(err);
+            process.exit(1);
+        }
+    },
+});
+
+module.exports = install;

package/lib/interface/cli/commands/helm/release/util.js

@@ -0,0 +1,16 @@
+const { sdk } = require('../../../../../logic');
+
+class HelmUtil {
+    // eslint-disable-next-line class-methods-use-this
+    async isHelm3(cluster) {
+        try {
+            const config = await sdk.helm['cluster-config'].get({
+                selector: cluster,
+            });
+            return config.helmVersion === 'helm3';
+        } catch (e) {
+            return false;
+        }
+    }
+}
+module.exports = new HelmUtil();

package/lib/interface/cli/commands/helm/repo/apply.cmd.js

@@ -0,0 +1,54 @@
+const Command = require('../../../Command');
+const { sdk } = require('../../../../../logic');
+
+const applyRoot = require('../../root/apply.cmd');
+
+
+const command = new Command({
+    command: 'helm-repo [name]',
+    aliases: [],
+    parent: applyRoot,
+    description: 'Update a helm repo',
+    webDocs: {
+        category: 'Helm Repos',
+        title: 'Update Helm Repo',
+    },
+    builder: (yargs) => {
+        yargs
+            .positional('name', {
+                describe: 'Old repo name',
+                required: true,
+            })
+            .option('public', {
+                describe: 'Mark the helm repo as public',
+                alias: 'p',
+                type: 'boolean',
+                default: undefined,
+            })
+            .option('newName', {
+                describe: 'New repo name',
+                alias: 'n',
+                type: 'string',
+            })
+            .example('codefresh patch helm-repo my-repo -p', 'Update helm repo to be public')
+            .example('codefresh patch helm-repo my-repo -p=false', 'Update helm repo to be private');
+
+        return yargs;
+    },
+    handler: async (argv) => {
+        if (!argv.name) {
+            throw new Error('Repo name must be provided');
+        }
+
+        const data = {
+            name: argv.newName,
+            public: argv.public,
+        };
+
+        await sdk.helm.repos.update({ name: argv.name }, data);
+        console.log(`Helm repo: ${argv.name} patched.`);
+    },
+});
+
+module.exports = command;
+

package/lib/interface/cli/commands/helm/repo/create.cmd.js

@@ -0,0 +1,46 @@
+const Command = require('../../../Command');
+const createRoot = require('../../root/create.cmd');
+const { sdk } = require('../../../../../logic');
+
+const command = new Command({
+    command: 'helm-repo [name]',
+    parent: createRoot,
+    description: 'Create a Codefresh managed helm repo',
+    usage: 'ATM it is only possible to create a helm repository against Codefresh managed helm registry',
+    webDocs: {
+        category: 'Helm Repos',
+        title: 'Create Helm Repo',
+    },
+    builder: (yargs) => {
+        yargs
+            .positional('name', {
+                describe: 'Name of repo',
+                required: true,
+            })
+            .option('public', {
+                describe: 'Mark the helm repo as public',
+                alias: 'p',
+                type: 'boolean',
+                default: false,
+            })
+            .example('codefresh create helm-repo', 'Create a private helm repo managed by Codefresh.')
+            .example('codefresh create helm-repo --public', 'Create a public helm repo managed by Codefresh.');
+
+        return yargs;
+    },
+    handler: async (argv) => {
+        if (!argv.name) throw new Error('Repo name must be provided');
+
+        const data = {
+            name: argv.name,
+            public: argv.public,
+        };
+
+        await sdk.helm.repos.create(data);
+        console.log(`Helm repo: ${data.name} created`);
+    },
+});
+
+
+module.exports = command;
+

package/lib/interface/cli/commands/helm/repo/delete.cmd.js

@@ -0,0 +1,37 @@
+const Command = require('../../../Command');
+const deleteRoot = require('../../root/delete.cmd');
+const { sdk } = require('../../../../../logic');
+
+
+const command = new Command({
+    command: 'helm-repo [name]',
+    aliases: [],
+    parent: deleteRoot,
+    description: 'Delete a helm repo',
+    webDocs: {
+        category: 'Helm Repos',
+        title: 'Delete Helm Repo',
+    },
+    builder: (yargs) => {
+        return yargs
+            .positional('name', {
+                describe: 'Helm repo name',
+                required: true,
+            })
+            .example('codefresh delete helm-repo my-repo', 'Delete a helm repo.');
+    },
+    handler: async (argv) => {
+        const { name } = argv;
+
+        if (!name) {
+            throw new Error('Repo name must be provided');
+        }
+
+        await sdk.helm.repos.delete({ name });
+        console.log(`Helm repo '${name}' deleted.`);
+    },
+});
+
+
+module.exports = command;
+

package/lib/interface/cli/commands/helm/repo/get.cmd.js

@@ -0,0 +1,61 @@
+const debug = require('debug')('codefresh:cli:create:pipelines2');
+const Command = require('../../../Command');
+const CFError = require('cf-errors');
+const _ = require('lodash');
+const Output = require('../../../../../output/Output');
+const { sdk } = require('../../../../../logic');
+const HelmRepo = require('../../../../../logic/entities/HelmRepo');
+
+const getRoot = require('../../root/get.cmd');
+
+
+const command = new Command({
+    command: 'helm-repo [name..]',
+    aliases: [],
+    parent: getRoot,
+    description: 'Get a specific helm-repo or an array of helm-repos',
+    webDocs: {
+        category: 'Helm Repos',
+        title: 'Get Helm Repo',
+    },
+    builder: (yargs) => {
+        yargs
+            .positional('name', {
+                describe: 'Helm repo name',
+            })
+            .example('codefresh get helm-repo', 'Get all helm repos')
+            .example('codefresh get helm-repo my-repo', 'Get a specific helm repo');
+        return yargs;
+    },
+    handler: async (argv) => {
+        const { name: names } = argv;
+
+        let repos;
+        if (!_.isEmpty(names)) {
+            repos = [];
+            for (const name of names) {
+                try {
+                    const currRepo = await sdk.helm.repos.get({ name });
+                    repos.push(currRepo);
+                } catch (err) {
+                    if (repos.length) {
+                        Output.print(repos);
+                    }
+
+                    debug(err.toString());
+                    const message = err.toString().includes('not find') ? `Helm repo '${name}' was not found.` : 'Error occurred';
+                    throw new CFError({
+                        cause: err,
+                        message,
+                    });
+                }
+            }
+        } else {
+            repos = await sdk.helm.repos.list();
+        }
+        Output.print(_.map(repos, HelmRepo.fromResponse));
+    },
+});
+
+module.exports = command;
+

package/lib/interface/cli/commands/helm/repo/helm-repo.sdk.spec.js

@@ -0,0 +1,58 @@
+const getCmd = require('./get.cmd').toCommand();
+const deleteCmd = require('./delete.cmd').toCommand();
+const createCmd = require('./create.cmd').toCommand();
+const applyCmd = require('./apply.cmd').toCommand();
+
+jest.mock('../../../../../logic/entities/HelmRepo');
+
+const request = require('requestretry');
+
+const DEFAULT_RESPONSE = request.__defaultResponse();
+
+describe('helm-repo commands', () => {
+    beforeEach(async () => {
+        request.__reset();
+        request.mockClear();
+        await configureSdk(); // eslint-disable-line
+    });
+
+    describe('get', () => {
+        it('should handle getting given name', async () => {
+            const argv = { name: ['some name'] };
+            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' };
+            await createCmd.handler(argv);
+            await verifyResponsesReturned([DEFAULT_RESPONSE]); // eslint-disable-line
+        });
+    });
+
+    describe('apply', () => {
+        it('should handle patching by name', async () => {
+            const argv = { name: 'some name' };
+            await applyCmd.handler(argv);
+            await verifyResponsesReturned([DEFAULT_RESPONSE]); // eslint-disable-line
+        });
+    });
+
+    describe('delete', () => {
+        it('should handle deletion given name', async () => {
+            const argv = { name: 'some name' };
+            await deleteCmd.handler(argv);
+            await verifyResponsesReturned([DEFAULT_RESPONSE]); // eslint-disable-line
+        });
+    });
+});

package/lib/interface/cli/commands/helm/set-helm-config.cmd.js

@@ -0,0 +1,93 @@
+const Command = require('../../Command');
+const { sdk } = require('../../../../logic');
+const Output = require('../../../../output/Output');
+const _ = require('lodash');
+
+const install = new Command({
+    root: true,
+    command: 'set-helm-config <cluster>',
+    description: 'Set Helm config',
+    webDocs: {
+        category: 'Predefined Pipelines',
+        title: 'Set Helm config',
+        weight: 20,
+    },
+    builder: (yargs) => {
+        return yargs
+            .positional('cluster', {
+                describe: 'Cluster name on integrations page',
+                required: true,
+            })
+            .option('version', {
+                describe: 'Major part of helm version (helm2 | helm3)',
+                alias: 'v',
+            })
+            .option('test-release-pipeline', {
+                describe: 'Pipeline for testing release',
+                alias: 't',
+            })
+            .option('rollback-pipeline', {
+                describe: 'Pipeline for rollback',
+                alias: 'r',
+            })
+            .option('delete-release-pipeline', {
+                describe: 'Pipeline for deleting release',
+                alias: 'd',
+            })
+            .option('tiller-namespace', {
+                describe: 'Tiller namespace for helm2',
+            })
+            .option('release-namespaces', {
+                describe: 'List of namespaces for using',
+            })
+            .example('codefresh set-helm-config cluster -v 2 -t pip1 -r pip2 -d pip3 --tiller-namespace kube-system', 'Helm2 config')
+            .example('codefresh set-helm-config cluster -v 3 -t pip1 -r pip2 -d pip3 --release-namespaces ns1 --release-namespaces ns2', 'Helm3 config');
+    },
+    handler: async (argv) => {
+        try {
+            if (!['helm2', 'helm3'].includes(argv.version)) {
+                throw new Error('Wrong version value');
+            }
+            let options = {};
+            options.selector = argv.cluster;
+            options.helmVersion = argv.version;
+
+            const pipelines = await sdk.pipelines.getNames({});
+
+            if (argv.deleteReleasePipeline) {
+                const pipeline = _.find(pipelines, p => p.metadata.name === argv.deleteReleasePipeline);
+                options.deleteReleasePipeline = _.get(pipeline, 'metadata.id');
+                if (!options.deleteReleasePipeline) {
+                    throw new Error(`Pipeline ${argv.deleteReleasePipeline} not found`);
+                }
+            }
+
+            if (argv.testReleasePipeline) {
+                const pipeline = _.find(pipelines, p => p.metadata.name === argv.testReleasePipeline);
+                options.testReleasePipeline = _.get(pipeline, 'metadata.id');
+                if (!options.testReleasePipeline) {
+                    throw new Error(`Pipeline ${argv.testReleasePipeline} not found`);
+                }
+            }
+
+            if (argv.rollbackPipeline) {
+                const pipeline = _.find(pipelines, p => p.metadata.name === argv.rollbackPipeline);
+                options.rollbackPipeline = _.get(pipeline, 'metadata.id');
+                if (!options.rollbackPipeline) {
+                    throw new Error(`Pipeline ${argv.rollbackPipeline} not found`);
+                }
+            }
+
+            options = _.merge(options, _.pick(argv, ['releaseNamespaces', 'tillerNamespace']));
+
+            await sdk.helm['cluster-config'].store(options);
+            console.log('Helm config was set successfully');
+            process.exit();
+        } catch (err) {
+            Output.printError(err);
+            process.exit(1);
+        }
+    },
+});
+
+module.exports = install;