codefresh 0.78.2

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

@@ -0,0 +1,61 @@
+const getCmd = require('./get.cmd').toCommand();
+const applyCmd = require('./apply.cmd').toCommand();
+const diffCmd = require('./diff.cmd').toCommand();
+
+jest.mock('../../../../logic/entities/RuntimeEnvironments');
+
+const request = require('requestretry');
+
+const DEFAULT_RESPONSE = request.__defaultResponse();
+
+describe('runtime environment commands', () => {
+    beforeEach(async () => {
+        request.__reset();
+        request.mockClear();
+        await configureSdk(); // eslint-disable-line
+    });
+
+    describe('get', () => {
+        it('should handle getting all for history', async () => {
+            const argv = { name: 'some name', history: true };
+            await getCmd.handler(argv);
+            await verifyResponsesReturned([DEFAULT_RESPONSE]); // eslint-disable-line
+        });
+
+        it('should handle getting by 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('apply', () => {
+        it('should handle patching given name (with setting default)', async () => {
+            const argv = { name: 'some name', extends: ['parent'], default: true };
+            await applyCmd.handler(argv);
+            await verifyResponsesReturned([DEFAULT_RESPONSE, DEFAULT_RESPONSE]); // eslint-disable-line
+        });
+    });
+
+    describe('diff', () => {
+        it('should handle diff given name', async () => {
+            const argv = {
+                'first-name': 'first name',
+                'second-name': 'first name',
+            };
+            await diffCmd.handler(argv);
+            await verifyResponsesReturned([DEFAULT_RESPONSE, DEFAULT_RESPONSE]); // eslint-disable-line
+        });
+    });
+});

package/lib/interface/cli/commands/runtimeEnvironments/uninstall.cmd.js

@@ -0,0 +1,149 @@
+/* eslint-disable max-len */
+const Command = require('../../Command');
+const unInstallRoot = require('../root/uninstall.cmd');
+const { sdk } = require('../../../../logic');
+const { getKubeContext } = require('../../helpers/kubernetes');
+const _ = require('lodash');
+const ProgressEvents = require('../../helpers/progressEvents');
+const cliProgress = require('cli-progress');
+const { DefaultLogFormatter } = require('./../hybrid/helper');
+
+
+const detachRuntimeFromAgent = async (agent, runtimeName) => {
+    const { runtimes } = agent;
+    const runtimeIdx = runtimes.findIndex(re => re === runtimeName);
+    runtimes.splice(runtimeIdx, 1);
+    await sdk.agents.update({ agentId: agent.id, runtimes });
+};
+
+const unInstallRuntimeCmd = new Command({
+    root: false,
+    parent: unInstallRoot,
+    command: 'runtime',
+    description: 'Uninstall a runtime on kubernetes cluster',
+    webDocs: {
+        category: 'Runtime-Environments',
+        title: 'Uninstall Runtime-Environment',
+        weight: 100,
+    },
+    builder: yargs => yargs
+        .env('CF_ARG_') // this means that every process.env.CF_ARG_* will be passed to argv
+        .option('agent-name', {
+            describe: 'Agent\'s name to be uninstalled',
+        })
+        .option('name', {
+            describe: 'Runtime\'s name to be uninstalled',
+        })
+        .option('agent-id', {
+            describe: 'Agent\'s ID',
+        })
+        .option('runtime-kube-context-name', {
+            describe: 'Name of the kubernetes context on which venona should be uninstalled [$CF_ARG_KUBE_CONTEXT_NAME]',
+        })
+        .option('runtime-kube-namespace', {
+            describe: 'Name of the namespace on which venona should be uninstalled [$CF_ARG_KUBE_NAMESPACE]',
+        })
+        .option('runtime-kube-config-path', {
+            describe: 'Path to kubeconfig file (default is $HOME/.kube/config)',
+        })
+        .option('agent-kube-context-name', {
+            describe: 'Agent kubernetes context',
+        })
+        .option('agent-kube-namespace', {
+            describe: 'Agent\'s namespace',
+        })
+        .option('agent-kube-config-path', {
+            describe: 'Path to kubeconfig file for the agent (default is $HOME/.kube/config)',
+        })
+        .option('verbose', {
+            describe: 'Print logs',
+        }),
+    handler: async (argv) => {
+        const {
+            'agent-name': agentName,
+            'agent-id': agentId,
+            name: runtimeName,
+            'runtime-kube-namespace': kubeNamespace,
+            'runtime-kube-config-path': kubeConfigPath,
+            'restart-agent': restartAgent,
+            'agent-kube-config-path': agentKubeConfigPath,
+            verbose,
+            terminateProcess,
+
+        } = argv;
+
+        let {
+            'runtime-kube-context-name': kubeContextName,
+            'agent-kube-context-name': agentKubeContextName,
+            'agent-kube-namespace': agentKubeNamespace,
+        } = argv;
+
+        if (!kubeContextName) {
+            kubeContextName = getKubeContext(kubeConfigPath);
+        }
+        if (!agentKubeContextName) {
+            agentKubeContextName = getKubeContext(agentKubeConfigPath);
+        }
+        if (!agentKubeNamespace) {
+            agentKubeNamespace = kubeNamespace;
+        }
+
+        let agent;
+        if (_.isNull(runtimeName) || _.isUndefined(runtimeName) || runtimeName === '') {
+            throw new Error('runtime name is mandatory');
+        }
+        if (agentName) {
+            agent = await sdk.agents.getByName({ name: agentName });
+        } else if (agentId) {
+            agent = await sdk.agents.get({ agentId });
+        } else {
+            throw new Error('agent name or agent id is needed');
+        }
+        if (agent === '' || !agent) {
+            throw new Error('agent was not found');
+        }
+
+        const runtimes = _.get(agent, 'runtimes', []);
+        if (!_.find(runtimes, value => value === runtimeName)) {
+            throw new Error(`Runtime ${runtimeName} is not attached to agent ${agent.name}`);
+        }
+        const runtimeIns = await sdk.runtimeEnvs.get({ name: runtimeName });
+        const storageClassName = _.get(runtimeIns, 'RuntimeScheduler.Pvcs.Dind.StorageClassName');
+        await detachRuntimeFromAgent(agent, runtimeName);
+
+        // Get agent
+
+        const events = new ProgressEvents();
+        const format = 'downloading [{bar}] {percentage}% | {value}/{total}';
+        const progressBar = new cliProgress.SingleBar({ stopOnComplete: true, format }, cliProgress.Presets.shades_classic);
+        let totalSize;
+        events.onStart((size) => {
+            progressBar.start(size, 0);
+            totalSize = size;
+        });
+        events.onProgress((progress) => {
+            progressBar.update(progress);
+            if (progress >= totalSize) {
+                console.log('\n');
+            }
+        });
+
+        await sdk.runtime.unInstall({
+            runtimeName,
+            kubeContextName,
+            kubeNamespace,
+            kubeConfigPath,
+            agentKubeContextName,
+            agentKubeNamespace,
+            agentKubeConfigPath,
+            restartAgent,
+            storageClassName,
+            verbose,
+            terminateProcess: (terminateProcess !== false),
+            events,
+            logFormatting: DefaultLogFormatter,
+        });
+    },
+});
+
+module.exports = unInstallRuntimeCmd;

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

@@ -0,0 +1,85 @@
+const Command = require('../../Command');
+const _ = require('lodash');
+const { sdk } = require('../../../../logic');
+
+const applyRoot = require('../root/apply.cmd');
+
+
+const command = new Command({
+    command: 'section [id]',
+    aliases: [],
+    parent: applyRoot,
+    description: 'Update a section',
+    webDocs: {
+        category: 'Section',
+        title: 'Update Section',
+    },
+    builder: (yargs) => {
+        yargs
+            .positional('id', {
+                describe: 'Id of existing section',
+            })
+            .option('boardId', {
+                describe: 'Id of existing board',
+            })
+            .option('boardName', {
+                describe: 'Name of existing board',
+            })
+            .option('name', {
+                describe: 'Name of existing section',
+            })
+            .option('newName', {
+                describe: 'New name',
+            })
+            .option('cluster', {
+                describe: 'Name of linked cluster',
+            })
+            .option('color', {
+                describe: 'New color',
+            })
+            .option('index', {
+                describe: 'New index',
+            })
+            .example(
+                'codefresh patch section ID --new-name NEW_NAME --filter /app-*/gi',
+                'Update name and filter of section. Specifying section by ID',
+            )
+            .example(
+                'codefresh patch section --name OLD_NAME --new-name NEW_NAME --filter /app-*/gi',
+                'Update name and filter of section. Specifying section by NAME',
+            );
+
+        return yargs;
+    },
+    handler: async (argv) => {
+        let { id, boardId } = argv;
+
+        if (!id) {
+            if (!argv.name) throw Error('Neither section-id nor section-name was specified');
+
+
+            if (!argv.boardId) {
+                if (!argv.boardName) throw Error('Neither board-id nor board-name was specified');
+
+                const boardObj = await sdk.helm.boards.getByName({ name: argv.boardName });
+                boardId = boardObj._id;
+            }
+
+            const sectionObj = await sdk.helm.sections.getByName({ boardId, name: argv.name });
+            id = sectionObj._id;
+        }
+
+        const data = _.merge({}, {
+            boardId,
+            section: argv.cluster,
+            color: argv.color,
+            index: argv.index,
+            name: argv.newName,
+        });
+
+        await sdk.helm.sections.patch({ id }, data);
+        console.log(`Section: "${argv.name}" patched.`);
+    },
+});
+
+module.exports = command;

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

@@ -0,0 +1,69 @@
+const Command = require('../../Command');
+const createRoot = require('../root/create.cmd');
+const { sdk } = require('../../../../logic');
+
+
+const command = new Command({
+    command: 'section <name>',
+    parent: createRoot,
+    description: 'Create a section',
+    usage: 'You can create a section specifying name unique for account.',
+    webDocs: {
+        category: 'Sections',
+        title: 'Create section',
+    },
+    builder: (yargs) => {
+        return yargs
+            .positional('name', {
+                describe: 'Name of section',
+                required: true,
+            })
+            .option('board-id', {
+                describe: 'Id of board where section is creating',
+            })
+            .option('board-name', {
+                describe: 'Name of board where section is creating',
+            })
+            .option('cluster', {
+                describe: 'Name of linked cluster',
+            })
+            .option('color', {
+                describe: 'Color of section',
+                default: '#CCAA00',
+            })
+            .option('index', {
+                describe: 'Index of section',
+                default: '1',
+            })
+            .example(
+                'codefresh create section NAME --board-name BOARD_NAME --cluster CLUSTER_NAME',
+                'Creating a section with board name',
+            )
+            .example(
+                'codefresh create section NAME --board-id ID --cluster CLUSTER_NAME --color "#00AACC" --index 1',
+                'Creating a section with board id',
+            );
+    },
+    handler: async (argv) => {
+        const reqBody = {
+            name: argv.name,
+            boardId: argv.boardId,
+            section: argv.cluster,
+            color: argv.color,
+            index: argv.index,
+        };
+
+        if (!reqBody.boardId) {
+            if (!argv.boardName) throw Error('Neither board-id nor board-name was specified');
+
+            const boardObj = await sdk.helm.boards.getByName({ name: argv.boardName });
+            reqBody.boardId = boardObj._id;
+        }
+
+        await sdk.helm.sections.create(reqBody);
+        console.log(`Section: "${reqBody.name}" created`);
+    },
+});
+
+
+module.exports = command;

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

@@ -0,0 +1,61 @@
+const Command = require('../../Command');
+const deleteRoot = require('../root/delete.cmd');
+const { sdk } = require('../../../../logic');
+
+
+const command = new Command({
+    command: 'section [id]',
+    aliases: [],
+    parent: deleteRoot,
+    description: 'Delete a section',
+    webDocs: {
+        category: 'Section',
+        title: 'Delete section',
+    },
+    builder: (yargs) => {
+        yargs
+            .positional('id', {
+                describe: 'section id',
+            })
+            .option('boardId', {
+                describe: 'board Id',
+            })
+            .option('boardName', {
+                describe: 'board name',
+            })
+            .option('name', {
+                describe: 'section name',
+            })
+            .example('codefresh delete section --board-name BOARD --name NAME', 'Delete section by board name and section name.')
+            .example('codefresh delete section SECTION_ID', 'Delete section by id.');
+        return yargs;
+    },
+    handler: async (argv) => {
+        const { name, boardName } = argv;
+        let { id, boardId } = argv;
+
+        // get section id
+        if (!id) {
+            if (!name) throw Error('Neither section-id nor section-name was specified');
+
+            // get board id
+            if (!boardId) {
+                if (!boardName) throw Error('Neither board-id nor board-name was specified');
+
+                const boardObj = await sdk.helm.boards.getByName({ name: boardName });
+                boardId = boardObj._id;
+            }
+
+
+            const sectionObj = await sdk.helm.sections.getByName({ boardId, name });
+            id = sectionObj._id;
+        }
+
+        await sdk.helm.sections.delete({ id });
+        console.log(`Section '${name || id}' deleted.`);
+    },
+});
+
+
+module.exports = command;
+

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

@@ -0,0 +1,79 @@
+const debug = require('debug')('codefresh:cli:create:pipelines2');
+const _ = require('lodash');
+const Command = require('../../Command');
+const CFError = require('cf-errors');
+const Output = require('../../../../output/Output');
+const getRoot = require('../root/get.cmd');
+const { sdk } = require('../../../../logic');
+const Section = require('../../../../logic/entities/Section');
+
+
+const command = new Command({
+    command: 'sections [id]',
+    aliases: ['section'],
+    parent: getRoot,
+    description: 'Get a specific section or an array of sections',
+    webDocs: {
+        category: 'Sections',
+        title: 'Get Section',
+    },
+    builder: (yargs) => {
+        return yargs
+            .option('board-id', {
+                describe: 'Board id',
+            })
+            .option('board-name', {
+                describe: 'Board name',
+            })
+            .positional('id', {
+                describe: 'Section by id',
+            })
+            .option('name', {
+                describe: 'Section by name',
+            });
+    },
+    handler: async (argv) => {
+        const { id, name, boardName } = argv;
+        let { boardId } = argv;
+        if (id) {
+            try {
+                const section = await sdk.helm.sections.get({ id });
+                Output.print(Section.fromResponse(section));
+            } catch (err) {
+                debug(err.toString());
+                const message = `Section '${id}' was not found`;
+                throw new CFError({
+                    cause: err,
+                    message,
+                });
+            }
+        } else {
+            if (!boardId) {
+                if (!boardName) throw Error('Neither board-id nor board-name was specified');
+
+                const boardObj = await sdk.helm.boards.getByName({ name: boardName });
+                boardId = boardObj._id;
+            }
+
+            if (name) {
+                try {
+                    const section = await sdk.helm.sections.getByName({ boardId, name });
+                    Output.print(Section.fromResponse(section));
+                } catch (err) {
+                    debug(err.toString());
+                    const message = `Section '${name}' was not found`;
+                    throw new CFError({
+                        cause: err,
+                        message,
+                    });
+                }
+            } else {
+                const sections = await sdk.helm.sections.list({ boardId });
+                Output.print(_.map(sections, Section.fromResponse));
+            }
+        }
+    },
+});
+
+module.exports = command;
+

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

@@ -0,0 +1,143 @@
+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/Section');
+
+const request = require('requestretry');
+
+const DEFAULT_RESPONSE = request.__defaultResponse();
+
+describe('section 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 given name and board id', async () => {
+            const argv = { name: 'some name', boardId: 'board id' };
+            await getCmd.handler(argv);
+            await verifyResponsesReturned([DEFAULT_RESPONSE]); // eslint-disable-line
+        });
+
+        it('should handle getting given name and board name', async () => {
+            const argv = { name: 'some name', boardName: 'board name' };
+            const responses = [
+                { statusCode: 200, body: { _id: 'board id' } },
+                DEFAULT_RESPONSE,
+            ];
+            request.__queueResponses(responses);
+            await getCmd.handler(argv);
+            await verifyResponsesReturned(responses); // eslint-disable-line
+        });
+
+        it('should handle getting all by board id', async () => {
+            const argv = { boardId: 'board id' };
+            const response = { statusCode: 200, body: [DEFAULT_RESPONSE.body] };
+            request.__setResponse(response);
+            await getCmd.handler(argv);
+            await verifyResponsesReturned([response]); // eslint-disable-line
+        });
+
+        it('should handle getting all by board name', async () => {
+            const argv = { boardName: 'board name' };
+            const responses = [
+                { statusCode: 200, body: { _id: 'board id' } },
+                { statusCode: 200, body: [DEFAULT_RESPONSE.body] },
+            ];
+            request.__queueResponses(responses);
+            await getCmd.handler(argv);
+            await verifyResponsesReturned(responses); // eslint-disable-line
+        });
+    });
+
+    describe('create', () => {
+        it('should handle creation given board id', async () => {
+            const argv = { boardId: 'board id' };
+            await createCmd.handler(argv);
+            await verifyResponsesReturned([DEFAULT_RESPONSE]); // eslint-disable-line
+        });
+
+        it('should handle creation given board name', async () => {
+            const argv = { boardName: 'board name' };
+            const responses = [
+                { statusCode: 200, body: { _id: 'board id' } },
+                DEFAULT_RESPONSE,
+            ];
+            request.__queueResponses(responses);
+            await createCmd.handler(argv);
+            await verifyResponsesReturned(responses); // eslint-disable-line
+        });
+    });
+
+    describe('apply', () => {
+        it('should handle patching by id', async () => {
+            const argv = { id: 'section id' };
+            await applyCmd.handler(argv);
+            await verifyResponsesReturned([DEFAULT_RESPONSE]); // eslint-disable-line
+        });
+
+        it('should handle patching by name and board id', async () => {
+            const argv = { boardId: 'board id', name: 'section name' };
+            const responses = [
+                { statusCode: 200, body: { _id: 'section id' } },
+                DEFAULT_RESPONSE,
+            ];
+            request.__queueResponses(responses);
+            await applyCmd.handler(argv);
+            await verifyResponsesReturned(responses); // eslint-disable-line
+        });
+
+        it('should handle patching by name and board name', async () => {
+            const argv = { boardName: 'board id', name: 'section name' };
+            const responses = [
+                { statusCode: 200, body: { _id: 'board id' } },
+                { statusCode: 200, body: { _id: 'section id' } },
+                DEFAULT_RESPONSE,
+            ];
+            request.__queueResponses(responses);
+            await applyCmd.handler(argv);
+            await verifyResponsesReturned(responses); // eslint-disable-line
+        });
+    });
+
+    describe('delete', () => {
+        it('should handle deleting by id', async () => {
+            const argv = { id: 'section id' };
+            await deleteCmd.handler(argv);
+            await verifyResponsesReturned([DEFAULT_RESPONSE]); // eslint-disable-line
+        });
+
+        it('should handle deleting by name and board id', async () => {
+            const argv = { boardId: 'board id', name: 'section name' };
+            const responses = [
+                { statusCode: 200, body: { _id: 'section id' } },
+                DEFAULT_RESPONSE,
+            ];
+            request.__queueResponses(responses);
+            await deleteCmd.handler(argv);
+            await verifyResponsesReturned(responses); // eslint-disable-line
+        });
+
+        it('should handle deleting by name and board name', async () => {
+            const argv = { boardName: 'board id', name: 'section name' };
+            const responses = [
+                { statusCode: 200, body: { _id: 'board id' } },
+                { statusCode: 200, body: { _id: 'section id' } },
+                DEFAULT_RESPONSE,
+            ];
+            request.__queueResponses(responses);
+            await deleteCmd.handler(argv);
+            await verifyResponsesReturned(responses); // eslint-disable-line
+        });
+    });
+});

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

@@ -0,0 +1,30 @@
+const Command = require('../../Command');
+const deleteRoot = require('../root/delete.cmd');
+const { sdk } = require('../../../../logic');
+
+
+const command = new Command({
+    command: 'step-type [name]',
+    parent: deleteRoot,
+    description: 'Delete a step-type',
+    webDocs: {
+        category: 'Step-types',
+        title: 'Delete Step-type',
+    },
+    builder: (yargs) => {
+        return yargs
+            .positional('name', {
+                describe: 'Step-type name',
+            });
+    },
+    handler: async (argv) => {
+        const { name } = argv;
+
+        await sdk.steps.delete({ name });
+        console.log(`Step-type '${name}' deleted.`);
+    },
+});
+
+
+module.exports = command;
+