codefresh 0.78.2

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

@@ -0,0 +1,205 @@
+/* eslint-disable max-len */
+const Command = require('../../Command');
+const installRoot = require('../root/install.cmd');
+const { sdk } = require('../../../../logic');
+const installRuntimeCmd = require('../runtimeEnvironments/install.cmd');
+const { getKubeContext } = require('../../helpers/kubernetes');
+const ProgressEvents = require('../../helpers/progressEvents');
+const cliProgress = require('cli-progress');
+const colors = require('colors');
+const { getNewAgentName } = require('./helper');
+const { DefaultLogFormatter } = require('./../hybrid/helper');
+
+const defaultNamespace = 'codefresh';
+
+const installAgentCmd = new Command({
+    root: false,
+    parent: installRoot,
+    command: 'agent',
+    description: 'Install and create an agent on kubernetes cluster',
+    webDocs: {
+        category: 'Agents',
+        title: 'Install',
+        weight: 100,
+    },
+    builder: yargs => yargs
+        .env('CF_ARG_') // this means that every process.env.CF_ARG_* will be passed to argv
+        .option('name', {
+            describe: 'Agent\'s name to be created if token is not provided',
+        })
+        .option('token', {
+            describe: 'Agent\'s token',
+        })
+        .option('kube-context-name', {
+            describe: 'Name of the kubernetes context on which runner should be installed [$CF_ARG_KUBE_CONTEXT_NAME]',
+        })
+        .option('kube-node-selector', {
+            describe: 'The kubernetes node selector "key=value" to be used by runner build resources (default is no node selector) (string)',
+        })
+        .option('dry-run', {
+            describe: 'Set to true to simulate installation',
+        })
+        .option('in-cluster', {
+            describe: 'Set flag if runner is been installed from inside a cluster',
+        })
+        .option('kube-namespace', {
+            describe: 'Name of the namespace on which runner should be installed [$CF_ARG_KUBE_NAMESPACE]',
+        })
+        .option('tolerations', {
+            describe: 'The kubernetes tolerations as path to a  JSON file to be used by runner resources (default is no tolerations) (string)',
+        })
+        .option('kube-config-path', {
+            describe: 'Path to kubeconfig file (default is $HOME/.kube/config)',
+        })
+        .option('skip-version-check', {
+            describe: 'Do not compare current runner\'s version with latest',
+        })
+        .option('install-runtime', {
+            describe: 'Install and attach runtime on the same namespace as the agent (default is false)',
+        })
+        .option('make-default-runtime', {
+            describe: 'should all pipelines run on the hybrid runtime (default is false)',
+        })
+        .option('storage-class-name', {
+            describe: 'Set a name of your custom storage class, note: this will not install volume provisioning components',
+        })
+        .option('agent-kube-context-name', {
+            describe: 'Agent kubernetes context (on attach)',
+        })
+        .option('agent-kube-namespace', {
+            describe: 'Agent\'s namespace (on attach)',
+        })
+        .option('docker-registry', {
+            describe: 'The prefix for the container registry that will be used for pulling the required components images. Example: --docker-registry="docker.io"',
+            type: 'string',
+        })
+        .option('verbose', {
+            describe: 'Print logs',
+        }),
+    handler: async (argv) => {
+        let {
+            name, token,
+        } = argv;
+        const {
+            'runtime-name': reName,
+            'skip-re-creation': skipRuntimeCreation,
+            'kube-node-selector': kubeNodeSelector,
+            'build-node-selector': buildNodeSelector,
+            'dry-run': dryRun,
+            'in-cluster': inCluster,
+            tolerations,
+            'kube-config-path': kubeConfigPath,
+            'skip-version-check': skipVersionCheck,
+            'install-runtime': installRuntime,
+            'make-default-runtime': shouldMakeDefaultRe,
+            'storage-class-name': storageClassName,
+            verbose,
+            terminateProcess,
+            'set-value': setValue,
+            'set-file': setFile,
+            'agent-kube-context-name': agentKubeContextName,
+            'agent-kube-namespace': agentKubeNamespace,
+            'docker-registry': dockerRegistry,
+            envVars,
+        } = argv;
+        let agent;
+        let {
+            'kube-context-name': kubeContextName,
+            'kube-namespace': kubeNamespace,
+        } = argv;
+        if (!kubeContextName) {
+            kubeContextName = getKubeContext(kubeConfigPath);
+        }
+        if (!kubeNamespace) {
+            kubeNamespace = defaultNamespace;
+        }
+        if (installRuntime && !agentKubeNamespace) {
+            throw new Error('agent-kube-namespace is a mandatory parameter when installing runtime');
+        }
+
+        if (!token) { // Create an agent if not provided
+            name = name || await getNewAgentName(kubeContextName, kubeNamespace);
+            agent = await sdk.agents.create({ name });
+            // eslint-disable-next-line prefer-destructuring
+            token = agent.token;
+            console.log(`A Codefresh Runner with the name: ${colors.cyan(name)} has been created.`);
+        } else {
+            // take the agent id from the token
+            const apiKey = token.split('.')[0];
+            const agentData = await sdk.tokens.getById({ id: apiKey });
+            if (!agentData) {
+                throw new Error('token is not valid');
+            }
+            const { subject } = agentData;
+
+            if (subject.type !== 'agent') {
+                throw new Error('token is not assosicated with a runner');
+            }
+            const agentId = agentData.subject.ref;
+            const data = await sdk.agents.get({ agentId });
+            // eslint-disable-next-line prefer-destructuring
+            name = data.name;
+        }
+        const apiHost = sdk.config.context.url;
+        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) => {
+            console.log('Downloading Codefresh Runner installer \n');
+            progressBar.start(size, 0);
+            totalSize = size;
+        });
+        events.onProgress((progress) => {
+            progressBar.update(progress);
+            if (progress >= totalSize) {
+                console.log('\n');
+            }
+        });
+        const agentInstallStatusCode = await sdk.agents.install({
+            apiHost,
+            kubeContextName,
+            kubeNamespace,
+            token,
+            dryRun,
+            inCluster,
+            kubeNodeSelector,
+            dockerRegistry,
+            tolerations,
+            kubeConfigPath,
+            skipVersionCheck,
+            verbose,
+            agentId: name,
+            terminateProcess,
+            events,
+            logFormatting: DefaultLogFormatter,
+            envVars,
+        });
+        if (agentInstallStatusCode !== 0) {
+            throw new Error(`\nRunner installation failed with code ${agentInstallStatusCode}`);
+        }
+        if (installRuntime) {
+            return installRuntimeCmd.handler({
+                'runtime-name': reName,
+                'skip-re-creation': skipRuntimeCreation,
+                'runtime-kube-context-name': kubeContextName,
+                'runtime-kube-namespace': kubeNamespace,
+                'agent-name': name,
+                'runtime-kube-config-path': kubeConfigPath,
+                'attach-runtime': true,
+                'restart-agent': true,
+                'make-default-runtime': shouldMakeDefaultRe,
+                'kube-node-selector': buildNodeSelector,
+                'storage-class-name': storageClassName,
+                'set-value': setValue,
+                'set-file': setFile,
+                'agent-kube-namespace': agentKubeNamespace,
+                'agent-kube-context-name': agentKubeContextName,
+                verbose,
+                terminateProcess,
+            });
+        }
+    },
+});
+
+module.exports = installAgentCmd;

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

@@ -0,0 +1,92 @@
+/* eslint-disable max-len */
+const Command = require('../../Command');
+const deleteAgent = require('../agent/delete.cmd');
+const unInstallRoot = require('../root/uninstall.cmd');
+const { sdk } = require('../../../../logic');
+const { getKubeContext } = require('../../helpers/kubernetes');
+const ProgressEvents = require('../../helpers/progressEvents');
+const cliProgress = require('cli-progress');
+const { DefaultLogFormatter } = require('./../hybrid/helper');
+
+
+const unInstallAgentCmd = new Command({
+    root: false,
+    parent: unInstallRoot,
+    command: 'agent',
+    description: 'Uninstall an agent on kubernetes cluster',
+    webDocs: {
+        category: 'Agents',
+        title: 'Uninstall',
+        weight: 100,
+    },
+    builder: yargs => yargs
+        .env('CF_ARG_') // this means that every process.env.CF_ARG_* will be passed to argv
+        .option('name', {
+            describe: 'Agent\'s name to be uninstalled',
+        })
+        .option('kube-context-name', {
+            describe: 'Name of the kubernetes context on which venona should be uninstalled [$CF_ARG_KUBE_CONTEXT_NAME]',
+        })
+        .option('kube-namespace', {
+            describe: 'Name of the namespace on which venona should be uninstalled [$CF_ARG_KUBE_NAMESPACE]',
+        })
+        .option('kube-config-path', {
+            describe: 'Path to kubeconfig file (default is $HOME/.kube/config)',
+        })
+        .option('verbose', {
+            describe: 'Print logs',
+        }),
+    handler: async (argv) => {
+        const {
+            name,
+            'kube-namespace': kubeNamespace,
+            'kube-config-path': kubeConfigPath,
+            terminateProcess,
+
+        } = argv;
+
+        let { 'kube-context-name': kubeContextName } = argv;
+
+        if (!kubeContextName) {
+            kubeContextName = getKubeContext(kubeConfigPath);
+        }
+
+        if (!name) {
+            throw new Error('Name is a mandatory parameter');
+        }
+
+        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');
+            }
+        });
+
+
+        const exitCode = await sdk.agents.unInstall({
+            kubeContextName,
+            kubeNamespace,
+            kubeConfigPath,
+            terminateProcess: false,
+            events,
+            logFormatting: DefaultLogFormatter,
+        });
+        if (exitCode === 0) {
+            console.log('Agent uninstalled successfully');
+            await deleteAgent.handler({ name, id: name });
+        }
+        if (terminateProcess !== false) {
+            process.exit(0);
+        }
+    },
+});
+
+module.exports = unInstallAgentCmd;

package/lib/interface/cli/commands/analyzer/analyze.cmd.js

@@ -0,0 +1,34 @@
+const _ = require('lodash');
+const Command = require('../../Command');
+const Logic = require('./analyzer.logic');
+
+const command = new Command({
+    root: true,
+    command: 'analyze <repoOwner> <repoName> [context]',
+    description: 'Analyzes your git repository and creates a proposed Codefresh pipeline that clones the source code and builds/packages it',
+    webDocs: {
+        category: 'Analyzer',
+        title: 'Analyze'
+    },
+    builder: yargs => yargs
+        .positional('repoOwner', {
+            describe: 'Repository owner',
+            required: true,
+        })
+        .positional('repoName', {
+            describe: 'Repository name',
+            required: true,
+        })
+        .positional('context', {
+            describe: 'Your git context that you can get from integrations -> git , if empty - using personal context',
+            required: false
+        })
+        .example('codefresh analyze elasticio petstore-component-nodejs github', 'Analyze repo'),
+    handler: async (argv) => {
+        const { repoOwner, repoName, context } = argv;
+        const yaml = await Logic.analyze({repoOwner, repoName, context});
+        console.log(yaml);
+    },
+});
+
+module.exports = command;

package/lib/interface/cli/commands/analyzer/analyzer.logic.js

@@ -0,0 +1,24 @@
+/* eslint-disable no-use-before-define,object-curly-newline,arrow-body-style */
+
+const { sdk } = require('../../../../logic');
+
+class AnalyzerLogic {
+
+    static async analyze({ repoOwner, repoName, context }) {
+
+        const repo = {
+            repoOwner,
+            repoName,
+            git: context,
+        };
+
+        return sdk.pipelines.analyze({
+            repo,
+            type: 'git',
+            source: 'api'
+        });
+    }
+
+}
+
+module.exports = AnalyzerLogic;

package/lib/interface/cli/commands/annotation/annotation.logic.js

@@ -0,0 +1,59 @@
+/* eslint-disable no-use-before-define,object-curly-newline,arrow-body-style */
+
+const _ = require('lodash');
+const CFError = require('cf-errors');
+const Promise = require('bluebird');
+const { sdk } = require('../../../../logic');
+
+class AnnotationLogic {
+    static async listAnnotations({ entityId, entityType, labels }) {
+        let annotations = [];
+        try {
+            annotations = await sdk.annotations.list({ entityId, entityType });
+        } catch (error) {
+            if (error.statusCode === 404) {
+                throw new CFError({
+                    message: `Annotations not found for specified entity: type = ${entityType}; id = ${entityId}`,
+                    cause: error,
+                });
+            } else {
+                throw error;
+            }
+        }
+
+        if (_.isArray(labels) && !_.isEmpty(labels)) {
+            annotations = _.filter(annotations, annotation => labels.includes(annotation.key));
+        }
+
+        return annotations;
+    }
+
+    static createAnnotations({ entityId, entityType, labels }) {
+        if (!_.isArray(labels)) {
+            throw new Error('Labels should be an array');
+        }
+        if (_.isEmpty(labels)) {
+            throw new Error('Labels are required for set command');
+        }
+
+        const annotations = AnnotationLogic._parseAnnotations(labels);
+        return Promise.map(annotations, ({ key, value }) => sdk.annotations.create({ entityId, entityType, key, value }), { concurrency: 1 });
+    }
+
+    static deleteAnnotations({ entityId, entityType, labels }) {
+        if (!_.isEmpty(labels)) {
+            return Promise.map(labels, key => sdk.annotations.delete({ entityId, entityType, key }), { concurrency: 1 });
+        }
+
+        return sdk.annotations.delete({ entityId, entityType });
+    }
+
+    static _parseAnnotations(labels) {
+        return _.map(labels, (label) => {
+            const [key, value] = label.split('=');
+            return { key, value };
+        });
+    }
+}
+
+module.exports = AnnotationLogic;

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

@@ -0,0 +1,64 @@
+const getCmd = require('./get.cmd').toCommand();
+const deleteCmd = require('./delete.cmd').toCommand();
+const createCmd = require('./create.cmd').toCommand();
+
+
+jest.mock('../../../../logic/entities/Annotation');
+
+const request = require('requestretry');
+
+const DEFAULT_RESPONSE = request.__defaultResponse();
+
+describe('annotation commands', () => {
+    beforeEach(async () => {
+        request.__reset();
+        request.mockClear();
+        await configureSdk(); // eslint-disable-line
+    });
+
+    describe('create', () => {
+        it('should handle creation', async () => {
+            const argv = { labels: ['some name'], 'entity-id': 'id', 'entity-type': 'image', _: [0, 0, 'key=value'] };
+            await createCmd.handler(argv);
+            await verifyResponsesReturned([DEFAULT_RESPONSE]); // eslint-disable-line
+        });
+    });
+
+    describe('get', () => {
+        it('should handle getting given id', async () => {
+            const argv = { 'entity-id': 'id', 'entity-type': 'image', _: [0, 0, 'test'] };
+            const response = { statusCode: 200, body: [{ key: 'test', value: 'test' }] };
+            request.__setResponse(response);
+            await getCmd.handler(argv);
+            await verifyResponsesReturned([response]); // eslint-disable-line
+        });
+
+        it('should handle getting given name', async () => {
+            const argv = { 'entity-id': 'id', 'entity-type': 'image', _: [0, 0] };
+            const response = { statusCode: 200, body: [{ test: 'test' }] };
+            request.__setResponse(response);
+            await getCmd.handler(argv);
+            await verifyResponsesReturned([response]); // eslint-disable-line
+        });
+
+        it('should handle getting all', async () => {
+            const argv = { 'entity-id': 'id', 'entity-type': 'image', _: [0, 0] };
+            const response = { statusCode: 200, body: [DEFAULT_RESPONSE.body] };
+            request.__setResponse(response);
+            await getCmd.handler(argv);
+            await verifyResponsesReturned([response]); // eslint-disable-line
+        });
+    });
+
+    describe('delete', () => {
+        it('should handle deletion given name', async () => {
+            const argv = { 'entity-id': 'id', 'entity-type': 'image', _: [0, 0, 'key'] };
+            const responses = [
+                DEFAULT_RESPONSE,
+            ];
+            request.__queueResponses(responses);
+            await deleteCmd.handler(argv);
+            await verifyResponsesReturned(responses); // eslint-disable-line
+        });
+    });
+});

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

@@ -0,0 +1,39 @@
+const _ = require('lodash');
+const Command = require('../../Command');
+const createRoot = require('../root/create.cmd');
+const Logic = require('./annotation.logic');
+
+const command = new Command({
+    parent: createRoot,
+    command: 'annotation <entity-type> <entity-id> <labels...>',
+    description: 'Annotate a resource with labels',
+    webDocs: {
+        category: 'Annotations',
+        title: 'create',
+        // weight: 50,
+    },
+    builder: yargs => yargs
+        .positional('entity-type', {
+            describe: 'Type of resource for annotation',
+            required: true,
+        })
+        .positional('entity-id', {
+            describe: 'Id of resource for annotation',
+            required: true,
+        })
+        .positional('labels', {
+            describe: 'Labels',
+            required: true,
+            array: true,
+        })
+        .example('codefresh create annotation image 2dfacdaad466 coverage=75%', 'Annotate entity with a single label')
+        .example('codefresh create annotation image 2dfacdaad466 coverage=75% tests_passed=true', 'Annotate entity with multiple labels'),
+    handler: async (argv) => {
+        const { entityType, entityId, labels } = argv;
+
+        await Logic.createAnnotations({ entityId, entityType, labels });
+        console.log('Annotations was created');
+    },
+});
+
+module.exports = command;

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

@@ -0,0 +1,38 @@
+const Command = require('../../Command');
+const _ = require('lodash');
+const deleteRoot = require('../root/delete.cmd');
+const Logic = require('./annotation.logic');
+
+const command = new Command({
+    parent: deleteRoot,
+    command: 'annotation <entity-type> <entity-id> [labels...]',
+    description: 'Delete annotations',
+    webDocs: {
+        category: 'Annotations',
+        title: 'delete',
+        // weight: 50,
+    },
+    builder: yargs => yargs
+        .positional('entity-type', {
+            describe: 'Type of resource for annotation',
+            required: true,
+        })
+        .positional('entity-id', {
+            describe: 'Id of resource for annotation',
+            required: true,
+        })
+        .positional('labels', {
+            describe: 'Labels to delete',
+            array: true,
+        })
+        .example('codefresh delete annotation image 2dfacdaad466 coverage tests_passed', 'Delete specified annotations')
+        .example('codefresh delete annotation image 2dfacdaad466', 'Delete all annotations of entity'),
+    handler: async (argv) => {
+        const { entityType, entityId, labels } = argv;
+
+        await Logic.deleteAnnotations({ entityId, entityType, labels });
+        console.log('Annotations was deleted');
+    },
+});
+
+module.exports = command;

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

@@ -0,0 +1,42 @@
+const _ = require('lodash');
+const Command = require('../../Command');
+const Logic = require('./annotation.logic');
+const Annotation = require('../../../../logic/entities/Annotation');
+const Output = require('../../../../output/Output');
+
+const getRoot = require('../root/get.cmd');
+
+const command = new Command({
+    parent: getRoot,
+    command: 'annotation <entity-type> <entity-id> [labels...]',
+    description: 'Get annotations',
+    webDocs: {
+        category: 'Annotations',
+        title: 'get',
+        // weight: 50,
+    },
+    builder: yargs => yargs
+        .positional('entity-type', {
+            describe: 'Type of resource for annotation',
+            required: true,
+        })
+        .positional('entity-id', {
+            describe: 'Id of resource for annotation',
+            required: true,
+        })
+        .positional('labels', {
+            describe: 'Labels to filter by',
+            array: true,
+            default: [],
+        })
+        .example('codefresh get annotation image 2dfacdaad466', 'Get all annotations for entity')
+        .example('codefresh get annotation image 2dfacdaad466 coverage tests_passed', 'Get specified annotations'),
+    handler: async (argv) => {
+        const { entityType, entityId, labels } = argv;
+
+        const annotations = await Logic.listAnnotations({ entityId, entityType, labels });
+        Output.print(_.map(annotations, Annotation.fromResponse));
+    },
+});
+
+module.exports = command;

package/lib/interface/cli/commands/app-proxy/helper.js

@@ -0,0 +1,63 @@
+const _ = require('lodash');
+const inquirer = require('inquirer');
+const YAML = require('yaml');
+const { readFileSync, lstatSync } = require('fs');
+const { resolve } = require('path');
+const { INSTALLATION_DEFAULTS } = require('../hybrid/helper');
+const { getKubeContext } = require('../../helpers/kubernetes');
+
+const selectRuntime = async (runtimes) => {
+    const ans = await inquirer.prompt({
+        type: 'list',
+        name: 're',
+        message: 'Name of Codefresh runtime-environment to use',
+        choices: runtimes,
+    });
+    return ans.re;
+};
+
+const selectNamespace = async () => {
+    const ans = await inquirer.prompt({
+        type: 'input',
+        name: 'namespace',
+        message: 'Name of Kubernetes namespace to use',
+        default: INSTALLATION_DEFAULTS.NAMESPACE,
+    });
+    return ans.namespace;
+};
+
+const selectHost = async () => {
+    const ans = await inquirer.prompt({
+        type: 'input',
+        name: 'host',
+        message: 'The hostname that will be used by the app-proxy ingress',
+    });
+    return ans.host;
+};
+
+const setIfNotDefined = (obj, prop, value) => {
+    _.set(obj, prop, _.get(obj, prop, value));
+};
+
+const mergeWithValues = (argv) => {
+    if (!argv.values || !lstatSync(resolve(process.cwd(), argv.values)).isFile()) {
+        return argv;
+    }
+    const valuesFileStr = readFileSync(resolve(process.cwd(), argv.values), 'utf8');
+    const valuesObj = YAML.parse(valuesFileStr);
+
+    setIfNotDefined(argv, 'kube-namespace', valuesObj.Namespace || INSTALLATION_DEFAULTS.NAMESPACE);
+    setIfNotDefined(argv, 'kube-context-name', valuesObj.Context || getKubeContext());
+    setIfNotDefined(argv, 'host', _.get(valuesObj, 'AppProxy.Ingress.Host'));
+    setIfNotDefined(argv, 'pathPrefix', _.get(valuesObj, 'AppProxy.Ingress.PathPrefix', ''));
+    setIfNotDefined(argv, 'runtime-environment', valuesObj.RuntimeEnvironmentName);
+
+    return argv;
+};
+
+module.exports = {
+    selectRuntime,
+    mergeWithValues,
+    selectNamespace,
+    selectHost,
+};