codefresh 0.78.2

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

@@ -0,0 +1,197 @@
+let createCmd = require('./create.cmd');
+let replaceCmd = require('./replace.cmd');
+let deleteCmd = require('./delete.cmd');
+let versionCmd = require('./version.cmd');
+let approveCmd = require('../workflow/approve.cmd');
+let denyCmd = require('../workflow/approve.cmd');
+let validateCmd = require('./validate.cmd');
+
+createCmd.requiresAuthentication = false;
+replaceCmd.requiresAuthentication = false;
+deleteCmd.requiresAuthentication = false;
+versionCmd.requiresAuthentication = false;
+approveCmd.requiresAuthentication = false;
+denyCmd.requiresAuthentication = false;
+validateCmd.requiresAuthentication = false;
+
+createCmd = createCmd.toCommand();
+replaceCmd = replaceCmd.toCommand();
+deleteCmd = deleteCmd.toCommand();
+versionCmd = versionCmd.toCommand();
+approveCmd = approveCmd.toCommand();
+denyCmd = denyCmd.toCommand();
+validateCmd = validateCmd.toCommand();
+
+jest.mock('../../helpers/validation', () => { // eslint-disable-line
+    return {
+        validatePipelineSpec: async () => ({ valid: true }),
+        validatePipelineYaml: async () => ({ valid: false }),
+    };
+});
+
+const request = require('requestretry');
+
+const DEFAULT_RESPONSE = request.__defaultResponse();
+
+describe('root commands', () => {
+    beforeEach(async () => {
+        request.__reset();
+        request.mockClear();
+        await configureSdk(); // eslint-disable-line
+    });
+
+    describe('create', () => {
+        describe('context', async () => {
+            it('should handle creation from spec', async () => {
+                const argv = {
+                    filename: {
+                        kind: 'context',
+                        metadata: {
+                            name: 'name',
+                        },
+                    },
+                };
+                await createCmd.handler(argv);
+                await verifyResponsesReturned([DEFAULT_RESPONSE]); // eslint-disable-line
+            });
+        });
+
+        describe('pipeline', async () => {
+            it('should handle creation from spec', async () => {
+                const argv = {
+                    filename: {
+                        kind: 'pipeline',
+                        metadata: {
+                            name: 'name',
+                        },
+                    },
+                };
+                await createCmd.handler(argv);
+                await verifyResponsesReturned([DEFAULT_RESPONSE]); // eslint-disable-line
+            });
+        });
+    });
+
+    describe('delete', () => {
+        describe('context', async () => {
+            it('should handle deletion by spec', async () => {
+                const argv = {
+                    filename: {
+                        kind: 'context',
+                        metadata: {
+                            name: 'name',
+                        },
+                    },
+                };
+                await deleteCmd.handler(argv);
+                await verifyResponsesReturned([DEFAULT_RESPONSE]); // eslint-disable-line
+            });
+        });
+
+        describe('pipeline', async () => {
+            it('should handle deletion by spec', async () => {
+                const argv = {
+                    filename: {
+                        kind: 'pipeline',
+                        metadata: {
+                            name: 'name',
+                        },
+                    },
+                };
+                await deleteCmd.handler(argv);
+                await verifyResponsesReturned([DEFAULT_RESPONSE]); // eslint-disable-line
+            });
+        });
+    });
+
+    describe('replace', () => {
+        describe('context', async () => {
+            it('should handle replacing by spec', async () => {
+                const argv = {
+                    filename: {
+                        kind: 'context',
+                        metadata: {
+                            name: 'name',
+                        },
+                    },
+                };
+                await replaceCmd.handler(argv);
+                await verifyResponsesReturned([DEFAULT_RESPONSE]); // eslint-disable-line
+            });
+        });
+
+        describe('pipeline', async () => {
+            it('should handle replacing by spec', async () => {
+                const argv = {
+                    filename: {
+                        kind: 'pipeline',
+                        metadata: {
+                            name: 'name',
+                        },
+                    },
+                };
+                await replaceCmd.handler(argv);
+                await verifyResponsesReturned([DEFAULT_RESPONSE]); // eslint-disable-line
+            });
+        });
+    });
+
+    describe('validate', () => {
+        describe('Not valid yaml ', async () => {
+            it('should throw error for not valid file', async () => {
+                const argv = {
+                    filenames: ['./codefresh.yml'],
+                };
+                const result = await validateCmd.handler(argv)
+                    .catch(err => err);
+                expect(result instanceof Error).toBe(true);
+            });
+        });
+    });
+
+    describe('version', () => {
+        describe('api', async () => {
+            it('should handle getting version', async () => {
+                const argv = { component: 'api' };
+                await versionCmd.handler(argv);
+                await verifyResponsesReturned([DEFAULT_RESPONSE]); // eslint-disable-line
+            });
+        });
+
+        describe('hermes', async () => {
+            it('should handle getting version', async () => {
+                const argv = { component: 'hermes' };
+                await versionCmd.handler(argv);
+                await verifyResponsesReturned([DEFAULT_RESPONSE]); // eslint-disable-line
+            });
+        });
+
+        describe('nomios', async () => {
+            it('should handle getting version', async () => {
+                const argv = { component: 'nomios' };
+                await versionCmd.handler(argv);
+                await verifyResponsesReturned([DEFAULT_RESPONSE]); // eslint-disable-line
+            });
+        });
+    });
+
+    describe('Approve pending-approval workflow', () => {
+        it('should handle approve from spec', async () => {
+            const argv = {
+                buildId: 'buildId'
+            };
+            await approveCmd.handler(argv);
+            await verifyResponsesReturned([DEFAULT_RESPONSE, DEFAULT_RESPONSE]); // eslint-disable-line
+        });
+    });
+
+    describe('Deny pending-approval workflow', () => {
+        it('should handle deny from spec', async () => {
+            const argv = {
+                buildId: 'buildId'
+            };
+            await denyCmd.handler(argv);
+            await verifyResponsesReturned([DEFAULT_RESPONSE, DEFAULT_RESPONSE]); // eslint-disable-line
+        });
+    });
+});

package/lib/interface/cli/commands/root/runner.cmd.js

@@ -0,0 +1,18 @@
+const Command = require('../../Command');
+
+
+const runner = new Command({
+    root: true,
+    command: 'runner',
+    description: 'Manage runner resources',
+    requiresAuthentication: argv => argv && !argv.token,
+    usage: 'Manage codefresh runner solution\'s components on kubernetes cluster',
+    webDocs: {
+        description: 'Manage and install runner resources',
+        category: 'Runner Resources',
+        title: 'Runner',
+        weight: 40,
+    },
+});
+
+module.exports = runner;

package/lib/interface/cli/commands/root/synchronize.cmd.js

@@ -0,0 +1,17 @@
+const Command = require('../../Command');
+
+const annotate = new Command({
+    root: true,
+    command: 'synchronize',
+    description: 'Synchronize a resource',
+    webDocs: {
+        title: 'synchronize',
+        weight: 100,
+    },
+    builder: (yargs) => {
+        return yargs
+            .demandCommand(1, 'You need at least one command before moving on');
+    },
+});
+
+module.exports = annotate;

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

@@ -0,0 +1,17 @@
+const Command = require('../../Command');
+
+
+const unInstall = new Command({
+    root: true,
+    command: 'uninstall',
+    description: 'Uninstall a resource',
+    usage: 'Uninstall operation will uninstall codefresh components on kubernetes cluster',
+    webDocs: {
+        description: 'Uninstall a resource',
+        category: 'Uninstall Resources',
+        title: 'Uninstall',
+        weight: 40,
+    },
+});
+
+module.exports = unInstall;

package/lib/interface/cli/commands/root/upgrade.cmd.js

@@ -0,0 +1,38 @@
+const CFError = require('cf-errors');
+const Command = require('../../Command');
+const { crudFilenameOption } = require('../../helpers/general');
+const yargs = require('yargs');
+
+
+const upgrade = new Command({
+    root: true,
+    command: 'upgrade',
+    description: 'Upgrade a resource by filename or stdin',
+    usage: 'Upgrade operation will apply only passed changes to an existing resource and will throw an error if the resource does not exist.\n\n Supported resources: \n\t\'Context\'',
+    webDocs: {
+        description: 'Upgrade a resource from a file, directory or url',
+        category: 'Operate On Resources',
+        title: 'Upgrade',
+        weight: 40,
+    },
+    builder: (yargs) => {
+        crudFilenameOption(yargs);
+        return yargs;
+    },
+    handler: async (argv) => {
+        if (!argv.filename) {
+            yargs.showHelp();
+        }
+
+        const data = argv.filename;
+        const entity = data.kind;
+
+        switch (entity) {
+            default:
+                throw new CFError(`Entity: ${entity} not supported`);
+        }
+
+    },
+});
+
+module.exports = upgrade;

package/lib/interface/cli/commands/root/validate.cmd.js

@@ -0,0 +1,119 @@
+const Command = require('../../Command');
+const _ = require('lodash');
+const Style = require('../../../../output/Style');
+const path = require('path');
+const { validatePipelineYaml } = require('../../helpers/validation');
+const { pathExists, watchFile } = require('../../helpers/general');
+const { PipelineValidationError } = require('../../../../logic/cli-config/errors');
+
+const VALID_MESSAGE = Style.green('Yaml is valid!');
+
+function _getResultMessage(result = {}) {
+    if (result.summarize) {
+        if (result.valid && !result.warning) {
+            return VALID_MESSAGE;
+        }
+        let message = '';
+        if (result.warning) {
+            message += `${result.warning}\n`;
+        }
+        if (result.message) {
+            message += `${result.message}\n`;
+        }
+        message += `${result.summarize}\n${result.documentationLinks}`;
+        return message;
+    }
+    return result.valid
+        ? VALID_MESSAGE
+        : `${Style.red(result.message)}\n`;
+}
+
+function printResult(result) {
+    console.log(_getResultMessage(result));
+}
+
+function _handleResult(result = {}, attach) {
+    if (result.valid || attach) {
+        return printResult(result);
+    }
+    throw new PipelineValidationError(_getResultMessage(result));
+}
+
+const validateCmd = new Command({
+    root: true,
+    command: 'validate [filenames..]',
+    description: 'Validate codefresh pipeline yaml config files.',
+    usage: 'Validate one or many pipeline yaml files or attach validator to one and validate on changes',
+    webDocs: {
+        description: 'Validate codefresh pipeline yaml config files',
+        category: 'Validation',
+        title: 'Validate pipeline yaml',
+        weight: 100,
+    },
+    builder: (yargs) => {
+        yargs
+            .positional('filenames', {
+                describe: 'Paths to yaml files',
+                required: true,
+            })
+            .option('attach', {
+                alias: 'a',
+                describe: 'Attach validator to the file and validate on change',
+            });
+
+
+        return yargs;
+    },
+    handler: async (argv) => {
+        let { filenames, attach } = argv;
+        filenames = filenames.map(f => path.resolve(process.cwd(), f));
+
+        if (_.isEmpty(filenames)) {
+            return console.log('No filename provided!');
+        }
+
+        const checkPromises = filenames.map(filename => pathExists(filename)
+            .then((exists) => {
+                if (!exists) {
+                    console.log(`File does not exist: ${filename}`);
+                }
+                return exists;
+            }));
+        const allExist = (await Promise.all(checkPromises)).reduce((a, b) => a && b);
+
+        if (!allExist) {
+            return;
+        }
+
+        if (filenames.length > 1) {
+            if (attach) {
+                console.log('Cannot watch many files!');
+                return;
+            }
+
+            filenames.forEach(f => validatePipelineYaml(f)
+                .then((result) => {
+                    console.log(`Validation result for ${f}:`);
+                    printResult(result);
+                }));
+            return;
+        }
+
+        const filename = filenames[0];
+        if (attach) {
+            console.log(`Validator attached to file: ${filename}`);
+            watchFile(filename, async () => {
+                console.log('File changed');
+                const result = await validatePipelineYaml(filename);
+                printResult(result);
+            });
+        }
+
+        // even with --attach option validates file for first time
+        const result = await validatePipelineYaml(filename);
+        _handleResult(result, attach);
+    },
+});
+
+module.exports = validateCmd;
+validateCmd.printResult = printResult;

package/lib/interface/cli/commands/root/validate.completion.js

@@ -0,0 +1,10 @@
+const { fileDir } = require('../../completion/helpers');
+
+function positionalHandler({ word, argv}) {
+    return fileDir(word);
+}
+
+module.exports = {
+    positionalHandler,
+};
+

package/lib/interface/cli/commands/root/version.cmd.js

@@ -0,0 +1,48 @@
+const Command = require('../../Command');
+const cliPackage = require('./../../../../../package.json');
+const openapi = require('./../../../../../openapi.json');
+const { sdk } = require('../../../../logic');
+
+const versionCmd = new Command({
+    root: true,
+    requiresAuthentication: false,
+    command: 'version [component]',
+    description: 'Print version',
+    webDocs: {
+        title: 'version',
+        weight: 90,
+    },
+    builder: (yargs) => {
+        return yargs
+            .option('component', {
+                describe: 'print component version',
+                alias: 'c',
+                choices: ['client', 'api', 'hermes', 'nomios', 'openapi'],
+                default: 'client',
+            });
+    },
+    handler: async (argv) => {
+        let ver = '';
+        switch (argv.component) {
+            case 'api':
+                ver = await sdk.version.getServerVersion();
+                ver = ver.current_commit;
+                break;
+            case 'hermes':
+                ver = await sdk.version.getHermesVersion();
+                break;
+            case 'nomios':
+                ver = await sdk.http({ url: '/nomios/version' }); // not '/api/nomios/version'
+                break;
+            case 'openapi':
+                ver = openapi.info.version;
+                break;
+            case 'client':
+            default:
+                ver = cliPackage.version;
+        }
+        console.log(argv.component, 'version:', ver);
+    },
+});
+
+module.exports = versionCmd;

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

@@ -0,0 +1,111 @@
+const Command = require('../../Command');
+const CFError = require('cf-errors');
+const _ = require('lodash');
+const applyRoot = require('../root/apply.cmd');
+const { crudFilenameOption } = require('../../helpers/general');
+const { sdk } = require('../../../../logic');
+
+
+const command = new Command({
+    command: 'runtime-environments [name]',
+    aliases: ['re', 'runtime-environment'],
+    parent: applyRoot,
+    description: 'apply changes to runtime-environments resource',
+    usage: 'Use apply to patch an existing context',
+    webDocs: {
+        category: 'Runtime-Environments',
+        title: 'Apply Runtime-Environments',
+        weight: 90,
+    },
+    builder: (yargs) => {
+        crudFilenameOption(yargs);
+        return yargs
+            .positional('name', {
+                describe: 'Runtime environments name',
+            })
+            .option('default', {
+                describe: 'Set the chosen runtime environment as default',
+            })
+            .option('extends', {
+                describe: 'Set the runtime environments you want to extends from',
+                type: Array,
+            })
+            .option('namespace', {
+                alias: 'ns',
+                describe: 'Set the desire namespace',
+            })
+            .option('cluster', {
+                alias: 'c',
+                describe: 'Set the desire cluster',
+            })
+            .option('description', {
+                alias: 'd',
+                describe: 'Description of the new runtime environment',
+            })
+            .example('codefresh patch runtime-environments -f ./re.yml', 'Apply changes to a runtime-environment');
+    },
+    handler: async (argv) => {
+        const option = {};
+        option.body = argv.filename || {};
+        option.name = _.get(option.body, 'metadata.name') || argv.name;
+        option.extend = _.get(option.body, 'extends') || argv.extends;
+        option.description = _.get(option.body, 'description') || argv.description;
+        option.dockerDaemonCluster = _.get(option.body, 'dockerDaemonScheduler.cluster.clusterProvider.selector') || argv.cluster;
+        option.dockerDaemonNamespace = _.get(option.body, 'dockerDaemonScheduler.cluster.namespace') || argv.namespace;
+        option.runtimeSchedulerCluster = _.get(option.body, 'runtimeScheduler.cluster.clusterProvider.selector') || argv.cluster;
+        option.runtimeSchedulerNamespace = _.get(option.body, 'runtimeScheduler.cluster.namespace') || argv.namespace;
+
+        if (!option.name) {
+            throw new CFError('Must Provide a runtime environment name');
+        }
+
+        if (argv.default) {
+            try {
+                await sdk.runtimeEnvs.setDefault({ name: option.name });
+                console.log(`Runtime-Environment: '${option.name}' set as a default.`);
+            } catch (err) {
+                throw new CFError(err);
+            }
+        }
+
+        if (!option.extend) {
+            throw new CFError('Must specify the runtime you want to extends from');
+        }
+
+        if (!option.dockerDaemonCluster || !option.runtimeSchedulerCluster || !option.dockerDaemonNamespace || !option.runtimeSchedulerNamespace) {
+            let extendsFromAccountRe = false;
+            _.forEach(argv.extends, (runtime) => {
+                if (!runtime.startsWith('system')) {
+                    extendsFromAccountRe = true;
+                }
+            });
+            if (!extendsFromAccountRe) {
+                throw new CFError('Must Provide cluster name and namespace or extends from existing account runtime environment');
+            }
+        }
+
+        if (!argv.filename) {
+            if (option.dockerDaemonCluster) {
+                _.set(option.body, 'dockerDaemonScheduler.cluster.clusterProvider.selector', option.dockerDaemonCluster);
+            }
+            if (option.runtimeSchedulerCluster) {
+                _.set(option.body, 'runtimeScheduler.cluster.clusterProvider.selector', option.runtimeSchedulerCluster);
+            }
+            if (option.dockerDaemonNamespace) {
+                _.set(option.body, 'dockerDaemonScheduler.cluster.namespace', option.dockerDaemonNamespace);
+            }
+            if (option.runtimeSchedulerNamespace) {
+                _.set(option.body, 'runtimeScheduler.cluster.namespace', option.runtimeSchedulerNamespace);
+            }
+        }
+
+        const { name, extend, body, description } = option;
+        await sdk.runtimeEnvs.update({ name, extend, description }, body);
+
+        console.log(`Runtime-Environment: '${option.name}' patched.`);
+    },
+});
+
+
+module.exports = command;
+